parallel ip - initial checkin

Signed-off-by: Ralf Mollik <ramollik@compex-commerce.com>
author: Ralf Mollik 2017-08-28 15:41:57 +0000
committer: Ralf Mollik 2017-08-28 15:41:57 +0000
commit: 6150c5c782fca1aabfa5910b9e584ebcad9ff3ce (patch)
tree: 23f37ef7cab96069de826f5c9fd4c2238826dbd5
download: org.eclipse.osbp.xtext.oxtype-6150c5c782fca1aabfa5910b9e584ebcad9ff3ce.tar.gz
org.eclipse.osbp.xtext.oxtype-6150c5c782fca1aabfa5910b9e584ebcad9ff3ce.tar.xz
org.eclipse.osbp.xtext.oxtype-6150c5c782fca1aabfa5910b9e584ebcad9ff3ce.zip
98 files changed, 130184 insertions, 0 deletions
diff --git a/.project b/.project
new file mode 100644
index 0000000..9d6926d
--- /dev/null
+++ b/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype.parent</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+	</natures>
+</projectDescription>
diff --git a/epl-v10.html b/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
+\ No newline at end of file
diff --git a/jenkins.build.config.xml b/jenkins.build.config.xml
new file mode 100644
index 0000000..7866a68
--- /dev/null
+++ b/jenkins.build.config.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--#======================================================================= -->
+<!--# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany)     					 			 -->
+<!--# All rights reserved. This program and the accompanying materials 		 -->
+<!--# are made available under the terms of the Eclipse Public License v1.0  -->
+<!--# which accompanies this distribution, and is available at               -->
+<!--# http://www.eclipse.org/legal/epl-v10.html                              -->
+<!--#                                                                        -->
+<!--# Contributors:                                                          -->
+<!--# Loetz GmbH&Co.KG - initial API and implementation                      -->
+<!--#======================================================================= -->
+<!--# Module specific parameters for the Jenkins Job 						 -->
+<!--#======================================================================= -->
+<jenkins>
+	<!-- DO NOT EDIT BELOW THIS LINE -->
+        <jenkins.build.dependencies>
+                <jenkins.build.dependency>org.eclipse.osbp.technologystack</jenkins.build.dependency>
+        </jenkins.build.dependencies>
+</jenkins>
diff --git a/notice.html b/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/notice.html
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>April 9, 2014</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+   repository (&quot;Repository&quot;) in software modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
+Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license (&quot;Feature Update License&quot;) during the
+installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager (&quot;Provisioning Technology&quot;) for the purpose of allowing users to install software, documentation, information and/or
+   other materials (collectively &quot;Installable Software&quot;). This capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+       href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   (&quot;Specification&quot;).</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+   in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+   Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur (&quot;Provisioning Process&quot;) in which a user may execute the Provisioning Technology
+       on a machine (&quot;Target Machine&quot;) with the intent of installing, extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+       Software (&quot;Installable Software Agreement&quot;) and such Installable Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+       the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+       indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/.project b/org.eclipse.osbp.xtext.oxtype.feature/.project
new file mode 100644
index 0000000..d55223b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/.project
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype.feature</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.pde.FeatureBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.sonarlint.eclipse.core.sonarlintBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.pde.FeatureNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/LICENSE.txt b/org.eclipse.osbp.xtext.oxtype.feature/LICENSE.txt
new file mode 100644
index 0000000..ff42ad4
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/LICENSE.txt
@@ -0,0 +1,161 @@
+Eclipse Public License -v 1.0
+
+THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION
+OR DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial code and documentation distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+
+i) changes to the Program, and
+
+ii) additions to the Program;
+
+where such changes and/or additions to the Program originate from and are distributed by that particular Contributor.
+A Contribution 'originates' from a Contributor if it was added to the Program by such Contributor itself or anyone
+acting on such Contributor's behalf. Contributions do not include additions to the Program which: (i) are separate
+modules of software distributed in conjunction with the Program under their own license agreement, and (ii) are not
+derivative works of the Program.
+
+"Contributor" means any person or entity that distributes the Program.
+
+"Licensed Patents " mean patent claims licensable by a Contributor which are necessarily infringed by the use or sale of
+its Contribution alone or when combined with the Program.
+
+"Program" means the Contributions distributed in accordance with this Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement, including all Contributors.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, distribute
+and sublicense the Contribution of such Contributor, if any, and such derivative works, in source code and object code
+form.
+
+b) Subject to the terms of this Agreement, each Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell, offer to sell, import and otherwise transfer the
+Contribution of such Contributor, if any, in source code and object code form. This patent license shall apply to the
+combination of the Contribution and the Program if, at the time the Contribution is added by the Contributor, such
+addition of the Contribution causes such combination to be covered by the Licensed Patents. The patent license shall not
+apply to any other combinations which include the Contribution. No hardware per se is licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the licenses to its Contributions set forth herein, no
+assurances are provided by any Contributor that the Program does not infringe the patent or other intellectual property
+rights of any other entity. Each Contributor disclaims any liability to Recipient for claims brought by any other entity
+based on infringement of intellectual property rights or otherwise. As a condition to exercising the rights and
+licenses granted hereunder, each Recipient hereby assumes sole responsibility to secure any other intellectual property
+rights needed, if any. For example, if a third party patent license is required to allow Recipient to distribute the
+Program, it is Recipient's responsibility to acquire that license before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has sufficient copyright rights in its Contribution, if any, to
+grant the copyright license set forth in this Agreement.
+
+3. REQUIREMENTS
+
+A Contributor may choose to distribute the Program in object code form under its own license agreement, provided that:
+
+a) it complies with the terms and conditions of this Agreement; and
+
+b) its license agreement:
+
+i) effectively disclaims on behalf of all Contributors all warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and implied warranties or conditions of merchantability and
+fitness for a particular purpose;
+
+ii) effectively excludes on behalf of all Contributors all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;
+
+iii) states that any provisions which differ from this Agreement are offered by that Contributor alone and not by any
+other party; and
+
+iv) states that source code for the Program is available from such Contributor, and informs licensees how to obtain it
+in a reasonable manner on or through a medium customarily used for software exchange.
+
+When the Program is made available in source code form:
+
+a) it must be made available under this Agreement; and
+
+b) a copy of this Agreement must be included with each copy of the Program.
+
+Contributors may not remove or alter any copyright notices contained within the Program.
+
+Each Contributor must identify itself as the originator of its Contribution, if any, in a manner that reasonably allows
+subsequent Recipients to identify the originator of the Contribution.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities with respect to end users, business partners and
+the like. While this license is intended to facilitate the commercial use of the Program, the Contributor who includes
+the Program in a commercial product offering should do so in a manner which does not create potential liability for
+other Contributors. Therefore, if a Contributor includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses") arising from claims, lawsuits and other legal actions
+brought by a third party against the Indemnified Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses relating to any actual or alleged intellectual
+property infringement. In order to qualify, an Indemnified Contributor must: a) promptly notify the Commercial
+Contributor in writing of such claim, and b) allow the Commercial Contributor to control, and cooperate with the
+Commercial Contributor in, the defense and any related settlement negotiations. The Indemnified Contributor may
+ participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial product offering, Product X. That Contributor is
+then a Commercial Contributor. If that Commercial Contributor then makes performance claims, or offers warranties
+related to Product X, those performance claims and warranties are such Commercial Contributor's responsibility alone.
+Under this section, the Commercial Contributor would have to defend claims against the other Contributors related to
+those performance claims and warranties, and if a court requires any other Contributor to pay any damages as a result,
+the Commercial Contributor must pay those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely responsible for
+determining the appropriateness of using and distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to the risks and costs of program errors, compliance
+with applicable laws, damage to or loss of data, programs or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS),
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under applicable law, it shall not affect the validity or
+enforceability of the remainder of the terms of this Agreement, and without further action by the parties hereto, such
+provision shall be reformed to the minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit)
+alleging that the Program itself (excluding combinations of the Program with other software or hardware) infringes such
+Recipient's patent(s), then such Recipient's rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it fails to comply with any of the material terms or
+conditions of this Agreement and does not cure such failure in a reasonable period of time after becoming aware of such
+noncompliance. If all Recipient's rights under this Agreement terminate, Recipient agrees to cease use and distribution
+of the Program as soon as reasonably practicable. However, Recipient's obligations under this Agreement and any licenses
+ granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement, but in order to avoid inconsistency the Agreement
+is copyrighted and may only be modified in the following manner. The Agreement Steward reserves the right to publish
+new versions (including revisions) of this Agreement from time to time. No one other than the Agreement Steward has the
+right to modify this Agreement. The Eclipse Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a suitable separate entity. Each new version of the
+Agreement will be given a distinguishing version number. The Program (including Contributions) may always be
+distributed subject to the version of the Agreement under which it was received. In addition, after a new version of
+the Agreement is published, Contributor may elect to distribute the Program (including its Contributions) under the
+new version. Except as expressly stated in Sections 2(a) and 2(b) above, Recipient receives no rights or licenses to
+the intellectual property of any Contributor under this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this Agreement are reserved.
+
+This Agreement is governed by the laws of the State of New York and the intellectual property laws of the United States
+of America. No party to this Agreement will bring a legal action under this Agreement more than one year after the cause
+of action arose. Each party waives its rights to a jury trial in any resulting litigation.
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/build.properties b/org.eclipse.osbp.xtext.oxtype.feature/build.properties
new file mode 100644
index 0000000..0ea4044
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/build.properties
@@ -0,0 +1,10 @@
+bin.includes = feature.xml,\
+               feature.properties,\
+               notice.html,\
+               license.html,\
+               LICENSE.txt,\
+               epl-v10.html
+src.includes = license.html,\
+               LICENSE.txt,\
+               notice.html,\
+               epl-v10.html			   
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/epl-v10.html b/org.eclipse.osbp.xtext.oxtype.feature/epl-v10.html
new file mode 100644
index 0000000..b398acc
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/epl-v10.html
@@ -0,0 +1,259 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Public License - Version 1.0</title>
+<style type="text/css">
+  body {
+    size: 8.5in 11.0in;
+    margin: 0.25in 0.5in 0.25in 0.5in;
+    tab-interval: 0.5in;
+    }
+  p {  	
+    margin-left: auto;
+    margin-top:  0.5em;
+    margin-bottom: 0.5em;
+    }
+  p.list {
+  	margin-left: 0.5in;
+    margin-top:  0.05em;
+    margin-bottom: 0.05em;
+    }
+  </style>
+
+</head>
+
+<body lang="EN-US">
+
+<h2>Eclipse Public License - v 1.0</h2>
+
+<p>THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR
+DISTRIBUTION OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS
+AGREEMENT.</p>
+
+<p><b>1. DEFINITIONS</b></p>
+
+<p>"Contribution" means:</p>
+
+<p class="list">a) in the case of the initial Contributor, the initial
+code and documentation distributed under this Agreement, and</p>
+<p class="list">b) in the case of each subsequent Contributor:</p>
+<p class="list">i) changes to the Program, and</p>
+<p class="list">ii) additions to the Program;</p>
+<p class="list">where such changes and/or additions to the Program
+originate from and are distributed by that particular Contributor. A
+Contribution 'originates' from a Contributor if it was added to the
+Program by such Contributor itself or anyone acting on such
+Contributor's behalf. Contributions do not include additions to the
+Program which: (i) are separate modules of software distributed in
+conjunction with the Program under their own license agreement, and (ii)
+are not derivative works of the Program.</p>
+
+<p>"Contributor" means any person or entity that distributes
+the Program.</p>
+
+<p>"Licensed Patents" mean patent claims licensable by a
+Contributor which are necessarily infringed by the use or sale of its
+Contribution alone or when combined with the Program.</p>
+
+<p>"Program" means the Contributions distributed in accordance
+with this Agreement.</p>
+
+<p>"Recipient" means anyone who receives the Program under
+this Agreement, including all Contributors.</p>
+
+<p><b>2. GRANT OF RIGHTS</b></p>
+
+<p class="list">a) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free copyright license to reproduce, prepare derivative works
+of, publicly display, publicly perform, distribute and sublicense the
+Contribution of such Contributor, if any, and such derivative works, in
+source code and object code form.</p>
+
+<p class="list">b) Subject to the terms of this Agreement, each
+Contributor hereby grants Recipient a non-exclusive, worldwide,
+royalty-free patent license under Licensed Patents to make, use, sell,
+offer to sell, import and otherwise transfer the Contribution of such
+Contributor, if any, in source code and object code form. This patent
+license shall apply to the combination of the Contribution and the
+Program if, at the time the Contribution is added by the Contributor,
+such addition of the Contribution causes such combination to be covered
+by the Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.</p>
+
+<p class="list">c) Recipient understands that although each Contributor
+grants the licenses to its Contributions set forth herein, no assurances
+are provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity. Each
+Contributor disclaims any liability to Recipient for claims brought by
+any other entity based on infringement of intellectual property rights
+or otherwise. As a condition to exercising the rights and licenses
+granted hereunder, each Recipient hereby assumes sole responsibility to
+secure any other intellectual property rights needed, if any. For
+example, if a third party patent license is required to allow Recipient
+to distribute the Program, it is Recipient's responsibility to acquire
+that license before distributing the Program.</p>
+
+<p class="list">d) Each Contributor represents that to its knowledge it
+has sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.</p>
+
+<p><b>3. REQUIREMENTS</b></p>
+
+<p>A Contributor may choose to distribute the Program in object code
+form under its own license agreement, provided that:</p>
+
+<p class="list">a) it complies with the terms and conditions of this
+Agreement; and</p>
+
+<p class="list">b) its license agreement:</p>
+
+<p class="list">i) effectively disclaims on behalf of all Contributors
+all warranties and conditions, express and implied, including warranties
+or conditions of title and non-infringement, and implied warranties or
+conditions of merchantability and fitness for a particular purpose;</p>
+
+<p class="list">ii) effectively excludes on behalf of all Contributors
+all liability for damages, including direct, indirect, special,
+incidental and consequential damages, such as lost profits;</p>
+
+<p class="list">iii) states that any provisions which differ from this
+Agreement are offered by that Contributor alone and not by any other
+party; and</p>
+
+<p class="list">iv) states that source code for the Program is available
+from such Contributor, and informs licensees how to obtain it in a
+reasonable manner on or through a medium customarily used for software
+exchange.</p>
+
+<p>When the Program is made available in source code form:</p>
+
+<p class="list">a) it must be made available under this Agreement; and</p>
+
+<p class="list">b) a copy of this Agreement must be included with each
+copy of the Program.</p>
+
+<p>Contributors may not remove or alter any copyright notices contained
+within the Program.</p>
+
+<p>Each Contributor must identify itself as the originator of its
+Contribution, if any, in a manner that reasonably allows subsequent
+Recipients to identify the originator of the Contribution.</p>
+
+<p><b>4. COMMERCIAL DISTRIBUTION</b></p>
+
+<p>Commercial distributors of software may accept certain
+responsibilities with respect to end users, business partners and the
+like. While this license is intended to facilitate the commercial use of
+the Program, the Contributor who includes the Program in a commercial
+product offering should do so in a manner which does not create
+potential liability for other Contributors. Therefore, if a Contributor
+includes the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and
+indemnify every other Contributor ("Indemnified Contributor")
+against any losses, damages and costs (collectively "Losses")
+arising from claims, lawsuits and other legal actions brought by a third
+party against the Indemnified Contributor to the extent caused by the
+acts or omissions of such Commercial Contributor in connection with its
+distribution of the Program in a commercial product offering. The
+obligations in this section do not apply to any claims or Losses
+relating to any actual or alleged intellectual property infringement. In
+order to qualify, an Indemnified Contributor must: a) promptly notify
+the Commercial Contributor in writing of such claim, and b) allow the
+Commercial Contributor to control, and cooperate with the Commercial
+Contributor in, the defense and any related settlement negotiations. The
+Indemnified Contributor may participate in any such claim at its own
+expense.</p>
+
+<p>For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those
+performance claims and warranties, and if a court requires any other
+Contributor to pay any damages as a result, the Commercial Contributor
+must pay those damages.</p>
+
+<p><b>5. NO WARRANTY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, THE PROGRAM IS
+PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS
+OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING, WITHOUT LIMITATION,
+ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT, MERCHANTABILITY
+OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely
+responsible for determining the appropriateness of using and
+distributing the Program and assumes all risks associated with its
+exercise of rights under this Agreement , including but not limited to
+the risks and costs of program errors, compliance with applicable laws,
+damage to or loss of data, programs or equipment, and unavailability or
+interruption of operations.</p>
+
+<p><b>6. DISCLAIMER OF LIABILITY</b></p>
+
+<p>EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, NEITHER RECIPIENT
+NOR ANY CONTRIBUTORS SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING
+WITHOUT LIMITATION LOST PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OR
+DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED
+HEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.</p>
+
+<p><b>7. GENERAL</b></p>
+
+<p>If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further action
+by the parties hereto, such provision shall be reformed to the minimum
+extent necessary to make such provision valid and enforceable.</p>
+
+<p>If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other
+software or hardware) infringes such Recipient's patent(s), then such
+Recipient's rights granted under Section 2(b) shall terminate as of the
+date such litigation is filed.</p>
+
+<p>All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of time
+after becoming aware of such noncompliance. If all Recipient's rights
+under this Agreement terminate, Recipient agrees to cease use and
+distribution of the Program as soon as reasonably practicable. However,
+Recipient's obligations under this Agreement and any licenses granted by
+Recipient relating to the Program shall continue and survive.</p>
+
+<p>Everyone is permitted to copy and distribute copies of this
+Agreement, but in order to avoid inconsistency the Agreement is
+copyrighted and may only be modified in the following manner. The
+Agreement Steward reserves the right to publish new versions (including
+revisions) of this Agreement from time to time. No one other than the
+Agreement Steward has the right to modify this Agreement. The Eclipse
+Foundation is the initial Agreement Steward. The Eclipse Foundation may
+assign the responsibility to serve as the Agreement Steward to a
+suitable separate entity. Each new version of the Agreement will be
+given a distinguishing version number. The Program (including
+Contributions) may always be distributed subject to the version of the
+Agreement under which it was received. In addition, after a new version
+of the Agreement is published, Contributor may elect to distribute the
+Program (including its Contributions) under the new version. Except as
+expressly stated in Sections 2(a) and 2(b) above, Recipient receives no
+rights or licenses to the intellectual property of any Contributor under
+this Agreement, whether expressly, by implication, estoppel or
+otherwise. All rights in the Program not expressly granted under this
+Agreement are reserved.</p>
+
+<p>This Agreement is governed by the laws of the State of New York and
+the intellectual property laws of the United States of America. No party
+to this Agreement will bring a legal action under this Agreement more
+than one year after the cause of action arose. Each party waives its
+rights to a jury trial in any resulting litigation.</p>
+
+
+
+</body></html>
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/feature.properties b/org.eclipse.osbp.xtext.oxtype.feature/feature.properties
new file mode 100644
index 0000000..2fef760
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/feature.properties
@@ -0,0 +1,172 @@
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation 
+#=======================================================================
+# feature.properties
+# contains externalized strings for feature.xml
+# "%foo" in feature.xml corresponds to the key "foo" in this file
+# java.io.Properties file (ISO 8859-1 with "\" escapes)
+# This file should be translated.
+
+# "featureName" property - name of the feature
+featureName =OSBP xtext.oxtype 
+
+# "providerName" property - name of the company that provides the feature
+providerName=Eclipse OSBP
+
+# "description" property - description of the feature
+description=This feature provides the OSBP xtext.oxtype bundle.
+
+# "updateSiteName" property - label for the update site
+updateSiteName=
+
+# "copyright" property - text of the "Feature Update Copyright"
+copyright=\
+Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany). \n\
+All rights reserved. This program and the accompanying materials\n\
+are made available under the terms of the Eclipse Public License v1.0\n\
+which accompanies this distribution, and is available at\n\
+http://www.eclipse.org/legal/epl-v10.html\n\
+\n\
+Contributors:\n\
+    Loetz GmbH&amp;Co.KG - initial API and basis\n\
+
+################ end of copyright property ####################################
+
+# "licenseURL" property - URL of the "Feature License"
+# do not translate value - just change to point to a locale-specific HTML page
+licenseURL=license.html
+
+# "license" property - text of the "Feature Update License"
+# should be plain text version of license agreement pointed to be "licenseURL"
+license=\
+Eclipse Foundation Software User Agreement\n\
+February 1, 2011\n\
+\n\
+Usage Of Content\n\
+\n\
+THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR\n\
+OTHER MATERIALS FOR OPEN SOURCE PROJECTS (COLLECTIVELY "CONTENT").\n\
+USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS\n\
+AGREEMENT AND/OR THE TERMS AND CONDITIONS OF LICENSE AGREEMENTS OR\n\
+NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU\n\
+AGREE THAT YOUR USE OF THE CONTENT IS GOVERNED BY THIS AGREEMENT\n\
+AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS\n\
+OR NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE\n\
+TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND CONDITIONS\n\
+OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED\n\
+BELOW, THEN YOU MAY NOT USE THE CONTENT.\n\
+\n\
+Applicable Licenses\n\
+\n\
+Unless otherwise indicated, all Content made available by the\n\
+Eclipse Foundation is provided to you under the terms and conditions of\n\
+the Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is\n\
+provided with this Content and is also available at http://www.eclipse.org/legal/epl-v10.html.\n\
+For purposes of the EPL, "Program" will mean the Content.\n\
+\n\
+Content includes, but is not limited to, source code, object code,\n\
+documentation and other files maintained in the Eclipse Foundation source code\n\
+repository ("Repository") in software modules ("Modules") and made available\n\
+as downloadable archives ("Downloads").\n\
+\n\
+       - Content may be structured and packaged into modules to facilitate delivering,\n\
+         extending, and upgrading the Content. Typical modules may include plug-ins ("Plug-ins"),\n\
+         plug-in fragments ("Fragments"), and features ("Features").\n\
+       - Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java(TM) ARchive)\n\
+         in a directory named "plugins".\n\
+       - A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.\n\
+         Each Feature may be packaged as a sub-directory in a directory named "features".\n\
+         Within a Feature, files named "feature.xml" may contain a list of the names and version\n\
+         numbers of the Plug-ins and/or Fragments associated with that Feature.\n\
+       - Features may also include other Features ("Included Features"). Within a Feature, files\n\
+         named "feature.xml" may contain a list of the names and version numbers of Included Features.\n\
+\n\
+The terms and conditions governing Plug-ins and Fragments should be\n\
+contained in files named "about.html" ("Abouts"). The terms and\n\
+conditions governing Features and Included Features should be contained\n\
+in files named "license.html" ("Feature Licenses"). Abouts and Feature\n\
+Licenses may be located in any directory of a Download or Module\n\
+including, but not limited to the following locations:\n\
+\n\
+       - The top-level (root) directory\n\
+       - Plug-in and Fragment directories\n\
+       - Inside Plug-ins and Fragments packaged as JARs\n\
+       - Sub-directories of the directory named "src" of certain Plug-ins\n\
+       - Feature directories\n\
+\n\
+Note: if a Feature made available by the Eclipse Foundation is installed using the\n\
+Provisioning Technology (as defined below), you must agree to a license ("Feature \n\
+Update License") during the installation process. If the Feature contains\n\
+Included Features, the Feature Update License should either provide you\n\
+with the terms and conditions governing the Included Features or inform\n\
+you where you can locate them. Feature Update Licenses may be found in\n\
+the "license" property of files named "feature.properties" found within a Feature.\n\
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the\n\
+terms and conditions (or references to such terms and conditions) that\n\
+govern your use of the associated Content in that directory.\n\
+\n\
+THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER\n\
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.\n\
+SOME OF THESE OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):\n\
+\n\
+       - Eclipse Distribution License Version 1.0 (available at http://www.eclipse.org/licenses/edl-v1.0.html)\n\
+       - Common Public License Version 1.0 (available at http://www.eclipse.org/legal/cpl-v10.html)\n\
+       - Apache Software License 1.1 (available at http://www.apache.org/licenses/LICENSE)\n\
+       - Apache Software License 2.0 (available at http://www.apache.org/licenses/LICENSE-2.0)\n\
+       - Metro Link Public License 1.00 (available at http://www.opengroup.org/openmotif/supporters/metrolink/license.html)\n\
+       - Mozilla Public License Version 1.1 (available at http://www.mozilla.org/MPL/MPL-1.1.html)\n\
+\n\
+IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR\n\
+TO USE OF THE CONTENT. If no About, Feature License, or Feature Update License\n\
+is provided, please contact the Eclipse Foundation to determine what terms and conditions\n\
+govern that particular Content.\n\
+\n\
+\n\Use of Provisioning Technology\n\
+\n\
+The Eclipse Foundation makes available provisioning software, examples of which include,\n\
+but are not limited to, p2 and the Eclipse Update Manager ("Provisioning Technology") for\n\
+the purpose of allowing users to install software, documentation, information and/or\n\
+other materials (collectively "Installable Software"). This capability is provided with\n\
+the intent of allowing such users to install, extend and update Eclipse-based products.\n\
+Information about packaging Installable Software is available at\n\
+http://eclipse.org/equinox/p2/repository_packaging.html ("Specification").\n\
+\n\
+You may use Provisioning Technology to allow other parties to install Installable Software.\n\
+You shall be responsible for enabling the applicable license agreements relating to the\n\
+Installable Software to be presented to, and accepted by, the users of the Provisioning Technology\n\
+in accordance with the Specification. By using Provisioning Technology in such a manner and\n\
+making it available in accordance with the Specification, you further acknowledge your\n\
+agreement to, and the acquisition of all necessary rights to permit the following:\n\
+\n\
+       1. A series of actions may occur ("Provisioning Process") in which a user may execute\n\
+          the Provisioning Technology on a machine ("Target Machine") with the intent of installing,\n\
+          extending or updating the functionality of an Eclipse-based product.\n\
+       2. During the Provisioning Process, the Provisioning Technology may cause third party\n\
+          Installable Software or a portion thereof to be accessed and copied to the Target Machine.\n\
+       3. Pursuant to the Specification, you will provide to the user the terms and conditions that\n\
+          govern the use of the Installable Software ("Installable Software Agreement") and such\n\
+          Installable Software Agreement shall be accessed from the Target Machine in accordance\n\
+          with the Specification. Such Installable Software Agreement must inform the user of the\n\
+          terms and conditions that govern the Installable Software and must solicit acceptance by\n\
+          the end user in the manner prescribed in such Installable Software Agreement. Upon such\n\
+          indication of agreement by the user, the provisioning Technology will complete installation\n\
+          of the Installable Software.\n\
+\n\
+Cryptography\n\
+\n\
+Content may contain encryption software. The country in which you are\n\
+currently may have restrictions on the import, possession, and use,\n\
+and/or re-export to another country, of encryption software. BEFORE\n\
+using any encryption software, please check the country's laws,\n\
+regulations and policies concerning the import, possession, or use, and\n\
+re-export of encryption software, to see if this is permitted.\n\
+\n\
+Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.\n
+########### end of license property ##########################################
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/feature.xml b/org.eclipse.osbp.xtext.oxtype.feature/feature.xml
new file mode 100644
index 0000000..3352960
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/feature.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<feature
+        id="org.eclipse.osbp.xtext.oxtype.feature"
+        label="%featureName"
+        version="0.9.0.qualifier"
+        provider-name="%providerName">
+        
+    <description>
+        %description
+    </description>
+        
+    <copyright>
+        %copyright
+    </copyright>
+        
+    <license url="%licenseURL">
+        %license
+    </license>
+        
+    <plugin
+        id="org.eclipse.osbp.xtext.oxtype"
+        download-size="0"
+        install-size="0"
+        version="0.0.0"
+        unpack="false"/>
+        
+        
+        
+</feature>
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/license.html b/org.eclipse.osbp.xtext.oxtype.feature/license.html
new file mode 100644
index 0000000..6e579a5
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/license.html
@@ -0,0 +1,164 @@
+<!--?xml version="1.0" encoding="ISO-8859-1" ?-->
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml"><head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>February 1, 2011</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY "CONTENT").  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse
+ Foundation is provided to you under the terms and conditions of the 
+Eclipse Public License Version 1.0
+   ("EPL").  A copy of the EPL is provided with this Content and is also
+ available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, "Program" will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, 
+documentation and other files maintained in the Eclipse Foundation 
+source code
+   repository ("Repository") in software modules ("Modules") and made 
+available as downloadable archives ("Downloads").</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to 
+facilitate delivering, extending, and upgrading the Content.  Typical 
+modules may include plug-ins ("Plug-ins"), plug-in fragments 
+("Fragments"), and features ("Features").</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&#8482; ARchive) in a directory named "plugins".</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or 
+Fragments and associated material.  Each Feature may be packaged as a 
+sub-directory in a directory named "features".  Within a Feature, files 
+named "feature.xml" may contain a list of the names and version numbers 
+of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features ("Included 
+Features"). Within a Feature, files named "feature.xml" may contain a 
+list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be 
+contained in files named "about.html" ("Abouts"). The terms and 
+conditions governing Features and
+Included Features should be contained in files named "license.html" 
+("Feature Licenses").  Abouts and Feature Licenses may be located in any
+ directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named "src" of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is 
+installed using the Provisioning Technology (as defined below), you must
+ agree to a license ("Feature Update License") during the
+installation process.  If the Feature contains Included Features, the 
+Feature Update License should either provide you with the terms and 
+conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be 
+found in the "license" property of files named "feature.properties" 
+found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the 
+terms and conditions (or references to such terms and conditions) that 
+govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER 
+TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.
+  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Metro Link Public License 1.00 (available at <a href="http://www.opengroup.org/openmotif/supporters/metrolink/license.html">http://www.opengroup.org/openmotif/supporters/metrolink/license.html</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND 
+CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, 
+or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions 
+govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, 
+examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager ("Provisioning Technology") for the purpose of 
+allowing users to install software, documentation, information and/or
+   other materials (collectively "Installable Software"). This 
+capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about 
+packaging Installable Software is available at <a href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   ("Specification").</p>
+
+<p>You may use Provisioning Technology to allow other parties to install
+ Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to
+ be presented to, and accepted by, the users of the Provisioning 
+Technology
+   in accordance with the Specification. By using Provisioning 
+Technology in such a manner and making it available in accordance with 
+the
+   Specification, you further acknowledge your agreement to, and the 
+acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur ("Provisioning Process") in 
+which a user may execute the Provisioning Technology
+       on a machine ("Target Machine") with the intent of installing, 
+extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology 
+may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user 
+the terms and conditions that govern the use of the Installable
+       Software ("Installable Software Agreement") and such Installable 
+Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable 
+Software Agreement must inform the user of the terms and conditions that
+ govern
+       the Installable Software and must solicit acceptance by the end 
+user in the manner prescribed in such Installable Software Agreement. 
+Upon such
+       indication of agreement by the user, the provisioning Technology 
+will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are
+ currently may have restrictions on the import, possession, and use, 
+and/or re-export to
+   another country, of encryption software. BEFORE using any encryption 
+software, please check the country's laws, regulations and policies 
+concerning the import,
+   possession, or use, and re-export of encryption software, to see if 
+this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+
+
+</body></html>
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/notice.html b/org.eclipse.osbp.xtext.oxtype.feature/notice.html
new file mode 100644
index 0000000..c3d34c3
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/notice.html
@@ -0,0 +1,107 @@
+<?xml version="1.0" encoding="ISO-8859-1" ?>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml">
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
+<title>Eclipse Foundation Software User Agreement</title>
+</head>
+
+<body lang="EN-US">
+<h2>Eclipse Foundation Software User Agreement</h2>
+<p>April 9, 2014</p>
+
+<h3>Usage Of Content</h3>
+
+<p>THE ECLIPSE FOUNDATION MAKES AVAILABLE SOFTWARE, DOCUMENTATION, INFORMATION AND/OR OTHER MATERIALS FOR OPEN SOURCE PROJECTS
+   (COLLECTIVELY &quot;CONTENT&quot;).  USE OF THE CONTENT IS GOVERNED BY THE TERMS AND CONDITIONS OF THIS AGREEMENT AND/OR THE TERMS AND
+   CONDITIONS OF LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW.  BY USING THE CONTENT, YOU AGREE THAT YOUR USE
+   OF THE CONTENT IS GOVERNED BY THIS AGREEMENT AND/OR THE TERMS AND CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR
+   NOTICES INDICATED OR REFERENCED BELOW.  IF YOU DO NOT AGREE TO THE TERMS AND CONDITIONS OF THIS AGREEMENT AND THE TERMS AND
+   CONDITIONS OF ANY APPLICABLE LICENSE AGREEMENTS OR NOTICES INDICATED OR REFERENCED BELOW, THEN YOU MAY NOT USE THE CONTENT.</p>
+
+<h3>Applicable Licenses</h3>
+
+<p>Unless otherwise indicated, all Content made available by the Eclipse Foundation is provided to you under the terms and conditions of the Eclipse Public License Version 1.0
+   (&quot;EPL&quot;).  A copy of the EPL is provided with this Content and is also available at <a href="http://www.eclipse.org/legal/epl-v10.html">http://www.eclipse.org/legal/epl-v10.html</a>.
+   For purposes of the EPL, &quot;Program&quot; will mean the Content.</p>
+
+<p>Content includes, but is not limited to, source code, object code, documentation and other files maintained in the Eclipse Foundation source code
+   repository (&quot;Repository&quot;) in software modules (&quot;Modules&quot;) and made available as downloadable archives (&quot;Downloads&quot;).</p>
+
+<ul>
+       <li>Content may be structured and packaged into modules to facilitate delivering, extending, and upgrading the Content.  Typical modules may include plug-ins (&quot;Plug-ins&quot;), plug-in fragments (&quot;Fragments&quot;), and features (&quot;Features&quot;).</li>
+       <li>Each Plug-in or Fragment may be packaged as a sub-directory or JAR (Java&trade; ARchive) in a directory named &quot;plugins&quot;.</li>
+       <li>A Feature is a bundle of one or more Plug-ins and/or Fragments and associated material.  Each Feature may be packaged as a sub-directory in a directory named &quot;features&quot;.  Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of the Plug-ins
+      and/or Fragments associated with that Feature.</li>
+       <li>Features may also include other Features (&quot;Included Features&quot;). Within a Feature, files named &quot;feature.xml&quot; may contain a list of the names and version numbers of Included Features.</li>
+</ul>
+
+<p>The terms and conditions governing Plug-ins and Fragments should be contained in files named &quot;about.html&quot; (&quot;Abouts&quot;). The terms and conditions governing Features and
+Included Features should be contained in files named &quot;license.html&quot; (&quot;Feature Licenses&quot;).  Abouts and Feature Licenses may be located in any directory of a Download or Module
+including, but not limited to the following locations:</p>
+
+<ul>
+       <li>The top-level (root) directory</li>
+       <li>Plug-in and Fragment directories</li>
+       <li>Inside Plug-ins and Fragments packaged as JARs</li>
+       <li>Sub-directories of the directory named &quot;src&quot; of certain Plug-ins</li>
+       <li>Feature directories</li>
+</ul>
+
+<p>Note: if a Feature made available by the Eclipse Foundation is installed using the Provisioning Technology (as defined below), you must agree to a license (&quot;Feature Update License&quot;) during the
+installation process.  If the Feature contains Included Features, the Feature Update License should either provide you with the terms and conditions governing the Included Features or
+inform you where you can locate them.  Feature Update Licenses may be found in the &quot;license&quot; property of files named &quot;feature.properties&quot; found within a Feature.
+Such Abouts, Feature Licenses, and Feature Update Licenses contain the terms and conditions (or references to such terms and conditions) that govern your use of the associated Content in
+that directory.</p>
+
+<p>THE ABOUTS, FEATURE LICENSES, AND FEATURE UPDATE LICENSES MAY REFER TO THE EPL OR OTHER LICENSE AGREEMENTS, NOTICES OR TERMS AND CONDITIONS.  SOME OF THESE
+OTHER LICENSE AGREEMENTS MAY INCLUDE (BUT ARE NOT LIMITED TO):</p>
+
+<ul>
+       <li>Eclipse Distribution License Version 1.0 (available at <a href="http://www.eclipse.org/licenses/edl-v10.html">http://www.eclipse.org/licenses/edl-v1.0.html</a>)</li>
+       <li>Common Public License Version 1.0 (available at <a href="http://www.eclipse.org/legal/cpl-v10.html">http://www.eclipse.org/legal/cpl-v10.html</a>)</li>
+       <li>Apache Software License 1.1 (available at <a href="http://www.apache.org/licenses/LICENSE">http://www.apache.org/licenses/LICENSE</a>)</li>
+       <li>Apache Software License 2.0 (available at <a href="http://www.apache.org/licenses/LICENSE-2.0">http://www.apache.org/licenses/LICENSE-2.0</a>)</li>
+       <li>Mozilla Public License Version 1.1 (available at <a href="http://www.mozilla.org/MPL/MPL-1.1.html">http://www.mozilla.org/MPL/MPL-1.1.html</a>)</li>
+</ul>
+
+<p>IT IS YOUR OBLIGATION TO READ AND ACCEPT ALL SUCH TERMS AND CONDITIONS PRIOR TO USE OF THE CONTENT.  If no About, Feature License, or Feature Update License is provided, please
+contact the Eclipse Foundation to determine what terms and conditions govern that particular Content.</p>
+
+
+<h3>Use of Provisioning Technology</h3>
+
+<p>The Eclipse Foundation makes available provisioning software, examples of which include, but are not limited to, p2 and the Eclipse
+   Update Manager (&quot;Provisioning Technology&quot;) for the purpose of allowing users to install software, documentation, information and/or
+   other materials (collectively &quot;Installable Software&quot;). This capability is provided with the intent of allowing such users to
+   install, extend and update Eclipse-based products. Information about packaging Installable Software is available at <a
+       href="http://eclipse.org/equinox/p2/repository_packaging.html">http://eclipse.org/equinox/p2/repository_packaging.html</a>
+   (&quot;Specification&quot;).</p>
+
+<p>You may use Provisioning Technology to allow other parties to install Installable Software. You shall be responsible for enabling the
+   applicable license agreements relating to the Installable Software to be presented to, and accepted by, the users of the Provisioning Technology
+   in accordance with the Specification. By using Provisioning Technology in such a manner and making it available in accordance with the
+   Specification, you further acknowledge your agreement to, and the acquisition of all necessary rights to permit the following:</p>
+
+<ol>
+       <li>A series of actions may occur (&quot;Provisioning Process&quot;) in which a user may execute the Provisioning Technology
+       on a machine (&quot;Target Machine&quot;) with the intent of installing, extending or updating the functionality of an Eclipse-based
+       product.</li>
+       <li>During the Provisioning Process, the Provisioning Technology may cause third party Installable Software or a portion thereof to be
+       accessed and copied to the Target Machine.</li>
+       <li>Pursuant to the Specification, you will provide to the user the terms and conditions that govern the use of the Installable
+       Software (&quot;Installable Software Agreement&quot;) and such Installable Software Agreement shall be accessed from the Target
+       Machine in accordance with the Specification. Such Installable Software Agreement must inform the user of the terms and conditions that govern
+       the Installable Software and must solicit acceptance by the end user in the manner prescribed in such Installable Software Agreement. Upon such
+       indication of agreement by the user, the provisioning Technology will complete installation of the Installable Software.</li>
+</ol>
+
+<h3>Cryptography</h3>
+
+<p>Content may contain encryption software. The country in which you are currently may have restrictions on the import, possession, and use, and/or re-export to
+   another country, of encryption software. BEFORE using any encryption software, please check the country's laws, regulations and policies concerning the import,
+   possession, or use, and re-export of encryption software, to see if this is permitted.</p>
+
+<p><small>Java and all Java-based trademarks are trademarks of Oracle Corporation in the United States, other countries, or both.</small></p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/pom.xml b/org.eclipse.osbp.xtext.oxtype.feature/pom.xml
new file mode 100644
index 0000000..2b8d8d8
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/pom.xml
@@ -0,0 +1,85 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation 
+#=======================================================================
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+        <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+       <version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+    </parent>
+
+    <artifactId>org.eclipse.osbp.xtext.oxtype.feature</artifactId>
+    <packaging>eclipse-feature</packaging>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.eclipse.tycho.extras</groupId>
+                <artifactId>tycho-source-feature-plugin</artifactId>
+                <version>${tychoExtrasVersion}</version>
+                <executions>
+                    <execution>
+                        <id>source-feature</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>source-feature</goal>
+                        </goals>
+                    </execution>
+                </executions>
+                <configuration>
+                    <labelSuffix> (source)</labelSuffix>
+                </configuration>
+            </plugin>
+            <plugin>
+                <!-- workaround while bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=398250 
+					is not fixed -->
+                <groupId>org.eclipse.tycho</groupId>
+                <artifactId>tycho-p2-plugin</artifactId>
+                <version>${tycho-version}</version>
+                <executions>
+                    <execution>
+                        <id>attached-p2-metadata</id>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>p2-metadata</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+			<plugin>
+				<artifactId>maven-javadoc-plugin</artifactId>
+				<executions>
+					<execution>
+						<id>javadoc-jar</id>
+						<phase>package</phase>
+						<goals>
+							<goal>jar</goal>
+						</goals>
+					</execution>
+				</executions>
+			</plugin>
+        </plugins>
+    </build>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+            <artifactId>org.eclipse.osbp.xtext.oxtype</artifactId>
+            <version>${project.version}</version>
+        </dependency>
+    </dependencies>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/src/main/javadoc/README.txt b/org.eclipse.osbp.xtext.oxtype.feature/src/main/javadoc/README.txt
new file mode 100644
index 0000000..831da7e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/src/main/javadoc/README.txt
@@ -0,0 +1 @@
+Resource folder for javadoc resources.
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.feature/src/overview.html b/org.eclipse.osbp.xtext.oxtype.feature/src/overview.html
new file mode 100644
index 0000000..8ef8212
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.feature/src/overview.html
@@ -0,0 +1,9 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
+<html>
+<head>
+	<title>OSBP xtext.oxtype</title>
+</head>
+<body>
+<p>The <strong>OSBP&nbsp;xtext.oxtype</strong> provides bundles for the OSBP xtext.oxtype functionality.</p>
+</body>
+</html>
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/.project b/org.eclipse.osbp.xtext.oxtype.ide/.project
new file mode 100644
index 0000000..8d5c39e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype.ide</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<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.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.ide/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..645fa2b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/META-INF/MANIFEST.MF
@@ -0,0 +1,15 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.ide
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.ide; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.osbp.xtext.oxtype,
+ org.eclipse.xtext.ide,
+ org.eclipse.xtext.xbase.ide,
+ org.antlr.runtime
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr,
+ org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal
+
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/build.properties b/org.eclipse.osbp.xtext.oxtype.ide/build.properties
new file mode 100644
index 0000000..5c6bbf9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/build.properties
@@ -0,0 +1,6 @@
+source.. = src/,\
+           src-gen/,\
+           xtend-gen/
+bin.includes = .,\
+               META-INF/
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/pom.xml b/org.eclipse.osbp.xtext.oxtype.ide/pom.xml
new file mode 100644
index 0000000..ee747b8
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/pom.xml
@@ -0,0 +1,22 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+		<artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.xtext.oxtype.ide</artifactId>
+	<packaging>eclipse-plugin</packaging>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup
new file mode 100644
index 0000000..e989786
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/META-INF/services/org.eclipse.xtext.ISetup
@@ -0,0 +1 @@
+org.eclipse.osbp.xtext.oxtype.ide.OXtypeIdeSetup
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/AbstractOXtypeIdeModule.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/AbstractOXtypeIdeModule.java
new file mode 100644
index 0000000..a14a8d1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/AbstractOXtypeIdeModule.java
@@ -0,0 +1,47 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide;
+
+import com.google.inject.Binder;
+import com.google.inject.name.Names;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.OXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal.InternalOXtypeLexer;
+import org.eclipse.xtext.ide.LexerIdeBindings;
+import org.eclipse.xtext.ide.editor.contentassist.FQNPrefixMatcher;
+import org.eclipse.xtext.ide.editor.contentassist.IPrefixMatcher;
+import org.eclipse.xtext.ide.editor.contentassist.IProposalConflictHelper;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.AntlrProposalConflictHelper;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
+import org.eclipse.xtext.xbase.ide.DefaultXbaseIdeModule;
+
+/**
+ * Manual modifications go to {@link OXtypeIdeModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractOXtypeIdeModule extends DefaultXbaseIdeModule {
+
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public void configureContentAssistLexer(Binder binder) {
+		binder.bind(Lexer.class)
+			.annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST))
+			.to(InternalOXtypeLexer.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends IContentAssistParser> bindIContentAssistParser() {
+		return OXtypeParser.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends IProposalConflictHelper> bindIProposalConflictHelper() {
+		return AntlrProposalConflictHelper.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.exporting.QualifiedNamesFragment2
+	public Class<? extends IPrefixMatcher> bindIPrefixMatcher() {
+		return FQNPrefixMatcher.class;
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/OXtypeParser.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/OXtypeParser.java
new file mode 100644
index 0000000..0e7d28b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/OXtypeParser.java
@@ -0,0 +1,452 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr;
+
+import com.google.inject.Inject;
+import java.util.HashMap;
+import java.util.Map;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal.InternalOXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.AbstractElement;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.AbstractContentAssistParser;
+
+public class OXtypeParser extends AbstractContentAssistParser {
+
+	@Inject
+	private OXtypeGrammarAccess grammarAccess;
+
+	private Map<AbstractElement, String> nameMappings;
+
+	@Override
+	protected InternalOXtypeParser createParser() {
+		InternalOXtypeParser result = new InternalOXtypeParser(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.getXImportDeclarationAccess().getAlternatives_2(), "rule__XImportDeclaration__Alternatives_2");
+					put(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3(), "rule__XImportDeclaration__Alternatives_2_0_3");
+					put(grammarAccess.getXAnnotationAccess().getAlternatives_3_1(), "rule__XAnnotation__Alternatives_3_1");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives(), "rule__XAnnotationElementValueOrCommaList__Alternatives");
+					put(grammarAccess.getXAnnotationElementValueAccess().getAlternatives(), "rule__XAnnotationElementValue__Alternatives");
+					put(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives(), "rule__XAnnotationOrExpression__Alternatives");
+					put(grammarAccess.getXAssignmentAccess().getAlternatives(), "rule__XAssignment__Alternatives");
+					put(grammarAccess.getOpMultiAssignAccess().getAlternatives(), "rule__OpMultiAssign__Alternatives");
+					put(grammarAccess.getOpEqualityAccess().getAlternatives(), "rule__OpEquality__Alternatives");
+					put(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1(), "rule__XRelationalExpression__Alternatives_1");
+					put(grammarAccess.getOpCompareAccess().getAlternatives(), "rule__OpCompare__Alternatives");
+					put(grammarAccess.getOpOtherAccess().getAlternatives(), "rule__OpOther__Alternatives");
+					put(grammarAccess.getOpOtherAccess().getAlternatives_5_1(), "rule__OpOther__Alternatives_5_1");
+					put(grammarAccess.getOpOtherAccess().getAlternatives_6_1(), "rule__OpOther__Alternatives_6_1");
+					put(grammarAccess.getOpAddAccess().getAlternatives(), "rule__OpAdd__Alternatives");
+					put(grammarAccess.getOpMultiAccess().getAlternatives(), "rule__OpMulti__Alternatives");
+					put(grammarAccess.getXUnaryOperationAccess().getAlternatives(), "rule__XUnaryOperation__Alternatives");
+					put(grammarAccess.getOpUnaryAccess().getAlternatives(), "rule__OpUnary__Alternatives");
+					put(grammarAccess.getOpPostfixAccess().getAlternatives(), "rule__OpPostfix__Alternatives");
+					put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1(), "rule__XMemberFeatureCall__Alternatives_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1(), "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1(), "rule__XMemberFeatureCall__Alternatives_1_1_3_1");
+					put(grammarAccess.getXPrimaryExpressionAccess().getAlternatives(), "rule__XPrimaryExpression__Alternatives");
+					put(grammarAccess.getXLiteralAccess().getAlternatives(), "rule__XLiteral__Alternatives");
+					put(grammarAccess.getXCollectionLiteralAccess().getAlternatives(), "rule__XCollectionLiteral__Alternatives");
+					put(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2(), "rule__XSwitchExpression__Alternatives_2");
+					put(grammarAccess.getXCasePartAccess().getAlternatives_3(), "rule__XCasePart__Alternatives_3");
+					put(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives(), "rule__XExpressionOrVarDeclaration__Alternatives");
+					put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1(), "rule__XVariableDeclaration__Alternatives_1");
+					put(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2(), "rule__XVariableDeclaration__Alternatives_2");
+					put(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1(), "rule__XFeatureCall__Alternatives_3_1");
+					put(grammarAccess.getFeatureCallIDAccess().getAlternatives(), "rule__FeatureCallID__Alternatives");
+					put(grammarAccess.getIdOrSuperAccess().getAlternatives(), "rule__IdOrSuper__Alternatives");
+					put(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1(), "rule__XConstructorCall__Alternatives_4_1");
+					put(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1(), "rule__XBooleanLiteral__Alternatives_1");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3(), "rule__XTryCatchFinallyExpression__Alternatives_3");
+					put(grammarAccess.getNumberAccess().getAlternatives(), "rule__Number__Alternatives");
+					put(grammarAccess.getNumberAccess().getAlternatives_1_0(), "rule__Number__Alternatives_1_0");
+					put(grammarAccess.getNumberAccess().getAlternatives_1_1_1(), "rule__Number__Alternatives_1_1_1");
+					put(grammarAccess.getJvmTypeReferenceAccess().getAlternatives(), "rule__JvmTypeReference__Alternatives");
+					put(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives(), "rule__JvmArgumentTypeReference__Alternatives");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2(), "rule__JvmWildcardTypeReference__Alternatives_2");
+					put(grammarAccess.getXImportDeclarationAccess().getGroup(), "rule__XImportDeclaration__Group__0");
+					put(grammarAccess.getXImportDeclarationAccess().getGroup_2_0(), "rule__XImportDeclaration__Group_2_0__0");
+					put(grammarAccess.getXImportDeclarationAccess().getGroup_2_3(), "rule__XImportDeclaration__Group_2_3__0");
+					put(grammarAccess.getXAnnotationAccess().getGroup(), "rule__XAnnotation__Group__0");
+					put(grammarAccess.getXAnnotationAccess().getGroup_3(), "rule__XAnnotation__Group_3__0");
+					put(grammarAccess.getXAnnotationAccess().getGroup_3_1_0(), "rule__XAnnotation__Group_3_1_0__0");
+					put(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1(), "rule__XAnnotation__Group_3_1_0_1__0");
+					put(grammarAccess.getXAnnotationElementValuePairAccess().getGroup(), "rule__XAnnotationElementValuePair__Group__0");
+					put(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0(), "rule__XAnnotationElementValuePair__Group_0__0");
+					put(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0(), "rule__XAnnotationElementValuePair__Group_0_0__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0(), "rule__XAnnotationElementValueOrCommaList__Group_0__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0(), "rule__XAnnotationElementValueOrCommaList__Group_0_0__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0(), "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1(), "rule__XAnnotationElementValueOrCommaList__Group_0_1__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1(), "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1(), "rule__XAnnotationElementValueOrCommaList__Group_1__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1(), "rule__XAnnotationElementValueOrCommaList__Group_1_1__0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1(), "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0");
+					put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0(), "rule__XAnnotationElementValue__Group_0__0");
+					put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0(), "rule__XAnnotationElementValue__Group_0_0__0");
+					put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0(), "rule__XAnnotationElementValue__Group_0_0_0__0");
+					put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1(), "rule__XAnnotationElementValue__Group_0_1__0");
+					put(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1(), "rule__XAnnotationElementValue__Group_0_1_1__0");
+					put(grammarAccess.getXAssignmentAccess().getGroup_0(), "rule__XAssignment__Group_0__0");
+					put(grammarAccess.getXAssignmentAccess().getGroup_1(), "rule__XAssignment__Group_1__0");
+					put(grammarAccess.getXAssignmentAccess().getGroup_1_1(), "rule__XAssignment__Group_1_1__0");
+					put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0(), "rule__XAssignment__Group_1_1_0__0");
+					put(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0(), "rule__XAssignment__Group_1_1_0_0__0");
+					put(grammarAccess.getOpMultiAssignAccess().getGroup_5(), "rule__OpMultiAssign__Group_5__0");
+					put(grammarAccess.getOpMultiAssignAccess().getGroup_6(), "rule__OpMultiAssign__Group_6__0");
+					put(grammarAccess.getXOrExpressionAccess().getGroup(), "rule__XOrExpression__Group__0");
+					put(grammarAccess.getXOrExpressionAccess().getGroup_1(), "rule__XOrExpression__Group_1__0");
+					put(grammarAccess.getXOrExpressionAccess().getGroup_1_0(), "rule__XOrExpression__Group_1_0__0");
+					put(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0(), "rule__XOrExpression__Group_1_0_0__0");
+					put(grammarAccess.getXAndExpressionAccess().getGroup(), "rule__XAndExpression__Group__0");
+					put(grammarAccess.getXAndExpressionAccess().getGroup_1(), "rule__XAndExpression__Group_1__0");
+					put(grammarAccess.getXAndExpressionAccess().getGroup_1_0(), "rule__XAndExpression__Group_1_0__0");
+					put(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0(), "rule__XAndExpression__Group_1_0_0__0");
+					put(grammarAccess.getXEqualityExpressionAccess().getGroup(), "rule__XEqualityExpression__Group__0");
+					put(grammarAccess.getXEqualityExpressionAccess().getGroup_1(), "rule__XEqualityExpression__Group_1__0");
+					put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0(), "rule__XEqualityExpression__Group_1_0__0");
+					put(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0(), "rule__XEqualityExpression__Group_1_0_0__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup(), "rule__XRelationalExpression__Group__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0(), "rule__XRelationalExpression__Group_1_0__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0(), "rule__XRelationalExpression__Group_1_0_0__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0(), "rule__XRelationalExpression__Group_1_0_0_0__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1(), "rule__XRelationalExpression__Group_1_1__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0(), "rule__XRelationalExpression__Group_1_1_0__0");
+					put(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0(), "rule__XRelationalExpression__Group_1_1_0_0__0");
+					put(grammarAccess.getOpCompareAccess().getGroup_1(), "rule__OpCompare__Group_1__0");
+					put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup(), "rule__XOtherOperatorExpression__Group__0");
+					put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1(), "rule__XOtherOperatorExpression__Group_1__0");
+					put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0(), "rule__XOtherOperatorExpression__Group_1_0__0");
+					put(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0(), "rule__XOtherOperatorExpression__Group_1_0_0__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_2(), "rule__OpOther__Group_2__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_5(), "rule__OpOther__Group_5__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_5_1_0(), "rule__OpOther__Group_5_1_0__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0(), "rule__OpOther__Group_5_1_0_0__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_6(), "rule__OpOther__Group_6__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_6_1_0(), "rule__OpOther__Group_6_1_0__0");
+					put(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0(), "rule__OpOther__Group_6_1_0_0__0");
+					put(grammarAccess.getXAdditiveExpressionAccess().getGroup(), "rule__XAdditiveExpression__Group__0");
+					put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1(), "rule__XAdditiveExpression__Group_1__0");
+					put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0(), "rule__XAdditiveExpression__Group_1_0__0");
+					put(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0(), "rule__XAdditiveExpression__Group_1_0_0__0");
+					put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup(), "rule__XMultiplicativeExpression__Group__0");
+					put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1(), "rule__XMultiplicativeExpression__Group_1__0");
+					put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0(), "rule__XMultiplicativeExpression__Group_1_0__0");
+					put(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0(), "rule__XMultiplicativeExpression__Group_1_0_0__0");
+					put(grammarAccess.getXUnaryOperationAccess().getGroup_0(), "rule__XUnaryOperation__Group_0__0");
+					put(grammarAccess.getXCastedExpressionAccess().getGroup(), "rule__XCastedExpression__Group__0");
+					put(grammarAccess.getXCastedExpressionAccess().getGroup_1(), "rule__XCastedExpression__Group_1__0");
+					put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0(), "rule__XCastedExpression__Group_1_0__0");
+					put(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0(), "rule__XCastedExpression__Group_1_0_0__0");
+					put(grammarAccess.getXPostfixOperationAccess().getGroup(), "rule__XPostfixOperation__Group__0");
+					put(grammarAccess.getXPostfixOperationAccess().getGroup_1(), "rule__XPostfixOperation__Group_1__0");
+					put(grammarAccess.getXPostfixOperationAccess().getGroup_1_0(), "rule__XPostfixOperation__Group_1_0__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup(), "rule__XMemberFeatureCall__Group__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0(), "rule__XMemberFeatureCall__Group_1_0__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0(), "rule__XMemberFeatureCall__Group_1_0_0__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0(), "rule__XMemberFeatureCall__Group_1_0_0_0__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1(), "rule__XMemberFeatureCall__Group_1_1__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0(), "rule__XMemberFeatureCall__Group_1_1_0__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0(), "rule__XMemberFeatureCall__Group_1_1_0_0__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_1__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2(), "rule__XMemberFeatureCall__Group_1_1_1_2__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3(), "rule__XMemberFeatureCall__Group_1_1_3__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1__0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1(), "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0");
+					put(grammarAccess.getXSetLiteralAccess().getGroup(), "rule__XSetLiteral__Group__0");
+					put(grammarAccess.getXSetLiteralAccess().getGroup_3(), "rule__XSetLiteral__Group_3__0");
+					put(grammarAccess.getXSetLiteralAccess().getGroup_3_1(), "rule__XSetLiteral__Group_3_1__0");
+					put(grammarAccess.getXListLiteralAccess().getGroup(), "rule__XListLiteral__Group__0");
+					put(grammarAccess.getXListLiteralAccess().getGroup_3(), "rule__XListLiteral__Group_3__0");
+					put(grammarAccess.getXListLiteralAccess().getGroup_3_1(), "rule__XListLiteral__Group_3_1__0");
+					put(grammarAccess.getXClosureAccess().getGroup(), "rule__XClosure__Group__0");
+					put(grammarAccess.getXClosureAccess().getGroup_0(), "rule__XClosure__Group_0__0");
+					put(grammarAccess.getXClosureAccess().getGroup_0_0(), "rule__XClosure__Group_0_0__0");
+					put(grammarAccess.getXClosureAccess().getGroup_1(), "rule__XClosure__Group_1__0");
+					put(grammarAccess.getXClosureAccess().getGroup_1_0(), "rule__XClosure__Group_1_0__0");
+					put(grammarAccess.getXClosureAccess().getGroup_1_0_0(), "rule__XClosure__Group_1_0_0__0");
+					put(grammarAccess.getXClosureAccess().getGroup_1_0_0_1(), "rule__XClosure__Group_1_0_0_1__0");
+					put(grammarAccess.getXExpressionInClosureAccess().getGroup(), "rule__XExpressionInClosure__Group__0");
+					put(grammarAccess.getXExpressionInClosureAccess().getGroup_1(), "rule__XExpressionInClosure__Group_1__0");
+					put(grammarAccess.getXShortClosureAccess().getGroup(), "rule__XShortClosure__Group__0");
+					put(grammarAccess.getXShortClosureAccess().getGroup_0(), "rule__XShortClosure__Group_0__0");
+					put(grammarAccess.getXShortClosureAccess().getGroup_0_0(), "rule__XShortClosure__Group_0_0__0");
+					put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1(), "rule__XShortClosure__Group_0_0_1__0");
+					put(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1(), "rule__XShortClosure__Group_0_0_1_1__0");
+					put(grammarAccess.getXParenthesizedExpressionAccess().getGroup(), "rule__XParenthesizedExpression__Group__0");
+					put(grammarAccess.getXIfExpressionAccess().getGroup(), "rule__XIfExpression__Group__0");
+					put(grammarAccess.getXIfExpressionAccess().getGroup_6(), "rule__XIfExpression__Group_6__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup(), "rule__XSwitchExpression__Group__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0(), "rule__XSwitchExpression__Group_2_0__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0(), "rule__XSwitchExpression__Group_2_0_0__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0(), "rule__XSwitchExpression__Group_2_0_0_0__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1(), "rule__XSwitchExpression__Group_2_1__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0(), "rule__XSwitchExpression__Group_2_1_0__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0(), "rule__XSwitchExpression__Group_2_1_0_0__0");
+					put(grammarAccess.getXSwitchExpressionAccess().getGroup_5(), "rule__XSwitchExpression__Group_5__0");
+					put(grammarAccess.getXCasePartAccess().getGroup(), "rule__XCasePart__Group__0");
+					put(grammarAccess.getXCasePartAccess().getGroup_2(), "rule__XCasePart__Group_2__0");
+					put(grammarAccess.getXCasePartAccess().getGroup_3_0(), "rule__XCasePart__Group_3_0__0");
+					put(grammarAccess.getXForLoopExpressionAccess().getGroup(), "rule__XForLoopExpression__Group__0");
+					put(grammarAccess.getXForLoopExpressionAccess().getGroup_0(), "rule__XForLoopExpression__Group_0__0");
+					put(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0(), "rule__XForLoopExpression__Group_0_0__0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup(), "rule__XBasicForLoopExpression__Group__0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3(), "rule__XBasicForLoopExpression__Group_3__0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1(), "rule__XBasicForLoopExpression__Group_3_1__0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7(), "rule__XBasicForLoopExpression__Group_7__0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1(), "rule__XBasicForLoopExpression__Group_7_1__0");
+					put(grammarAccess.getXWhileExpressionAccess().getGroup(), "rule__XWhileExpression__Group__0");
+					put(grammarAccess.getXDoWhileExpressionAccess().getGroup(), "rule__XDoWhileExpression__Group__0");
+					put(grammarAccess.getXBlockExpressionAccess().getGroup(), "rule__XBlockExpression__Group__0");
+					put(grammarAccess.getXBlockExpressionAccess().getGroup_2(), "rule__XBlockExpression__Group_2__0");
+					put(grammarAccess.getXVariableDeclarationAccess().getGroup(), "rule__XVariableDeclaration__Group__0");
+					put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0(), "rule__XVariableDeclaration__Group_2_0__0");
+					put(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0(), "rule__XVariableDeclaration__Group_2_0_0__0");
+					put(grammarAccess.getXVariableDeclarationAccess().getGroup_3(), "rule__XVariableDeclaration__Group_3__0");
+					put(grammarAccess.getJvmFormalParameterAccess().getGroup(), "rule__JvmFormalParameter__Group__0");
+					put(grammarAccess.getFullJvmFormalParameterAccess().getGroup(), "rule__FullJvmFormalParameter__Group__0");
+					put(grammarAccess.getXFeatureCallAccess().getGroup(), "rule__XFeatureCall__Group__0");
+					put(grammarAccess.getXFeatureCallAccess().getGroup_1(), "rule__XFeatureCall__Group_1__0");
+					put(grammarAccess.getXFeatureCallAccess().getGroup_1_2(), "rule__XFeatureCall__Group_1_2__0");
+					put(grammarAccess.getXFeatureCallAccess().getGroup_3(), "rule__XFeatureCall__Group_3__0");
+					put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1(), "rule__XFeatureCall__Group_3_1_1__0");
+					put(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1(), "rule__XFeatureCall__Group_3_1_1_1__0");
+					put(grammarAccess.getXConstructorCallAccess().getGroup(), "rule__XConstructorCall__Group__0");
+					put(grammarAccess.getXConstructorCallAccess().getGroup_3(), "rule__XConstructorCall__Group_3__0");
+					put(grammarAccess.getXConstructorCallAccess().getGroup_3_2(), "rule__XConstructorCall__Group_3_2__0");
+					put(grammarAccess.getXConstructorCallAccess().getGroup_4(), "rule__XConstructorCall__Group_4__0");
+					put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1(), "rule__XConstructorCall__Group_4_1_1__0");
+					put(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1(), "rule__XConstructorCall__Group_4_1_1_1__0");
+					put(grammarAccess.getXBooleanLiteralAccess().getGroup(), "rule__XBooleanLiteral__Group__0");
+					put(grammarAccess.getXNullLiteralAccess().getGroup(), "rule__XNullLiteral__Group__0");
+					put(grammarAccess.getXNumberLiteralAccess().getGroup(), "rule__XNumberLiteral__Group__0");
+					put(grammarAccess.getXStringLiteralAccess().getGroup(), "rule__XStringLiteral__Group__0");
+					put(grammarAccess.getXTypeLiteralAccess().getGroup(), "rule__XTypeLiteral__Group__0");
+					put(grammarAccess.getXThrowExpressionAccess().getGroup(), "rule__XThrowExpression__Group__0");
+					put(grammarAccess.getXReturnExpressionAccess().getGroup(), "rule__XReturnExpression__Group__0");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup(), "rule__XTryCatchFinallyExpression__Group__0");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0(), "rule__XTryCatchFinallyExpression__Group_3_0__0");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1(), "rule__XTryCatchFinallyExpression__Group_3_0_1__0");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1(), "rule__XTryCatchFinallyExpression__Group_3_1__0");
+					put(grammarAccess.getXSynchronizedExpressionAccess().getGroup(), "rule__XSynchronizedExpression__Group__0");
+					put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0(), "rule__XSynchronizedExpression__Group_0__0");
+					put(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0(), "rule__XSynchronizedExpression__Group_0_0__0");
+					put(grammarAccess.getXCatchClauseAccess().getGroup(), "rule__XCatchClause__Group__0");
+					put(grammarAccess.getQualifiedNameAccess().getGroup(), "rule__QualifiedName__Group__0");
+					put(grammarAccess.getQualifiedNameAccess().getGroup_1(), "rule__QualifiedName__Group_1__0");
+					put(grammarAccess.getNumberAccess().getGroup_1(), "rule__Number__Group_1__0");
+					put(grammarAccess.getNumberAccess().getGroup_1_1(), "rule__Number__Group_1_1__0");
+					put(grammarAccess.getStaticQualifierAccess().getGroup(), "rule__StaticQualifier__Group__0");
+					put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0(), "rule__JvmTypeReference__Group_0__0");
+					put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1(), "rule__JvmTypeReference__Group_0_1__0");
+					put(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0(), "rule__JvmTypeReference__Group_0_1_0__0");
+					put(grammarAccess.getArrayBracketsAccess().getGroup(), "rule__ArrayBrackets__Group__0");
+					put(grammarAccess.getXFunctionTypeRefAccess().getGroup(), "rule__XFunctionTypeRef__Group__0");
+					put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0(), "rule__XFunctionTypeRef__Group_0__0");
+					put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1(), "rule__XFunctionTypeRef__Group_0_1__0");
+					put(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1(), "rule__XFunctionTypeRef__Group_0_1_1__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup(), "rule__JvmParameterizedTypeReference__Group__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1(), "rule__JvmParameterizedTypeReference__Group_1__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2(), "rule__JvmParameterizedTypeReference__Group_1_2__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4(), "rule__JvmParameterizedTypeReference__Group_1_4__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0(), "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2__0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2(), "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup(), "rule__JvmWildcardTypeReference__Group__0");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0(), "rule__JvmWildcardTypeReference__Group_2_0__0");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1(), "rule__JvmWildcardTypeReference__Group_2_1__0");
+					put(grammarAccess.getJvmUpperBoundAccess().getGroup(), "rule__JvmUpperBound__Group__0");
+					put(grammarAccess.getJvmUpperBoundAndedAccess().getGroup(), "rule__JvmUpperBoundAnded__Group__0");
+					put(grammarAccess.getJvmLowerBoundAccess().getGroup(), "rule__JvmLowerBound__Group__0");
+					put(grammarAccess.getJvmLowerBoundAndedAccess().getGroup(), "rule__JvmLowerBoundAnded__Group__0");
+					put(grammarAccess.getJvmTypeParameterAccess().getGroup(), "rule__JvmTypeParameter__Group__0");
+					put(grammarAccess.getJvmTypeParameterAccess().getGroup_1(), "rule__JvmTypeParameter__Group_1__0");
+					put(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup(), "rule__QualifiedNameWithWildcard__Group__0");
+					put(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup(), "rule__QualifiedNameInStaticImport__Group__0");
+					put(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0(), "rule__XImportDeclaration__StaticAssignment_2_0_0");
+					put(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1(), "rule__XImportDeclaration__ExtensionAssignment_2_0_1");
+					put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2(), "rule__XImportDeclaration__ImportedTypeAssignment_2_0_2");
+					put(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0(), "rule__XImportDeclaration__WildcardAssignment_2_0_3_0");
+					put(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1(), "rule__XImportDeclaration__MemberNameAssignment_2_0_3_1");
+					put(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1(), "rule__XImportDeclaration__ImportedTypeAssignment_2_1");
+					put(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2(), "rule__XImportDeclaration__ImportedNamespaceAssignment_2_2");
+					put(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0(), "rule__XImportDeclaration__FqnImportAssignment_2_3_0");
+					put(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1(), "rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1");
+					put(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2(), "rule__XAnnotation__AnnotationTypeAssignment_2");
+					put(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0(), "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0");
+					put(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1(), "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1");
+					put(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1(), "rule__XAnnotation__ValueAssignment_3_1_1");
+					put(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0(), "rule__XAnnotationElementValuePair__ElementAssignment_0_0_0");
+					put(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1(), "rule__XAnnotationElementValuePair__ValueAssignment_1");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0(), "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1(), "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1");
+					put(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1(), "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1");
+					put(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0(), "rule__XAnnotationElementValue__ElementsAssignment_0_1_0");
+					put(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1(), "rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1");
+					put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1(), "rule__XAssignment__FeatureAssignment_0_1");
+					put(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3(), "rule__XAssignment__ValueAssignment_0_3");
+					put(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XAssignment__FeatureAssignment_1_1_0_0_1");
+					put(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1(), "rule__XAssignment__RightOperandAssignment_1_1_1");
+					put(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOrExpression__FeatureAssignment_1_0_0_1");
+					put(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOrExpression__RightOperandAssignment_1_1");
+					put(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAndExpression__FeatureAssignment_1_0_0_1");
+					put(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAndExpression__RightOperandAssignment_1_1");
+					put(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XEqualityExpression__FeatureAssignment_1_0_0_1");
+					put(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1(), "rule__XEqualityExpression__RightOperandAssignment_1_1");
+					put(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1(), "rule__XRelationalExpression__TypeAssignment_1_0_1");
+					put(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1(), "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1");
+					put(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1(), "rule__XRelationalExpression__RightOperandAssignment_1_1_1");
+					put(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1");
+					put(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1(), "rule__XOtherOperatorExpression__RightOperandAssignment_1_1");
+					put(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1");
+					put(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1(), "rule__XAdditiveExpression__RightOperandAssignment_1_1");
+					put(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1(), "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1");
+					put(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1(), "rule__XMultiplicativeExpression__RightOperandAssignment_1_1");
+					put(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1(), "rule__XUnaryOperation__FeatureAssignment_0_1");
+					put(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2(), "rule__XUnaryOperation__OperandAssignment_0_2");
+					put(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1(), "rule__XCastedExpression__TypeAssignment_1_1");
+					put(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1(), "rule__XPostfixOperation__FeatureAssignment_1_0_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2");
+					put(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1(), "rule__XMemberFeatureCall__ValueAssignment_1_0_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1(), "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2(), "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2");
+					put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1(), "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2(), "rule__XMemberFeatureCall__FeatureAssignment_1_1_2");
+					put(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0(), "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0");
+					put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1");
+					put(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4(), "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4");
+					put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0(), "rule__XSetLiteral__ElementsAssignment_3_0");
+					put(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1(), "rule__XSetLiteral__ElementsAssignment_3_1_1");
+					put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0(), "rule__XListLiteral__ElementsAssignment_3_0");
+					put(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1(), "rule__XListLiteral__ElementsAssignment_3_1_1");
+					put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0");
+					put(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1(), "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1");
+					put(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1(), "rule__XClosure__ExplicitSyntaxAssignment_1_0_1");
+					put(grammarAccess.getXClosureAccess().getExpressionAssignment_2(), "rule__XClosure__ExpressionAssignment_2");
+					put(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0(), "rule__XExpressionInClosure__ExpressionsAssignment_1_0");
+					put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0");
+					put(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1(), "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1");
+					put(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2(), "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2");
+					put(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1(), "rule__XShortClosure__ExpressionAssignment_1");
+					put(grammarAccess.getXIfExpressionAccess().getIfAssignment_3(), "rule__XIfExpression__IfAssignment_3");
+					put(grammarAccess.getXIfExpressionAccess().getThenAssignment_5(), "rule__XIfExpression__ThenAssignment_5");
+					put(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1(), "rule__XIfExpression__ElseAssignment_6_1");
+					put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1(), "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1");
+					put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1(), "rule__XSwitchExpression__SwitchAssignment_2_0_1");
+					put(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0(), "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0");
+					put(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1(), "rule__XSwitchExpression__SwitchAssignment_2_1_1");
+					put(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4(), "rule__XSwitchExpression__CasesAssignment_4");
+					put(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2(), "rule__XSwitchExpression__DefaultAssignment_5_2");
+					put(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1(), "rule__XCasePart__TypeGuardAssignment_1");
+					put(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1(), "rule__XCasePart__CaseAssignment_2_1");
+					put(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1(), "rule__XCasePart__ThenAssignment_3_0_1");
+					put(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1(), "rule__XCasePart__FallThroughAssignment_3_1");
+					put(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3(), "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3");
+					put(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1(), "rule__XForLoopExpression__ForExpressionAssignment_1");
+					put(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3(), "rule__XForLoopExpression__EachExpressionAssignment_3");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1(), "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5(), "rule__XBasicForLoopExpression__ExpressionAssignment_5");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1(), "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1");
+					put(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9(), "rule__XBasicForLoopExpression__EachExpressionAssignment_9");
+					put(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3(), "rule__XWhileExpression__PredicateAssignment_3");
+					put(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5(), "rule__XWhileExpression__BodyAssignment_5");
+					put(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2(), "rule__XDoWhileExpression__BodyAssignment_2");
+					put(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5(), "rule__XDoWhileExpression__PredicateAssignment_5");
+					put(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0(), "rule__XBlockExpression__ExpressionsAssignment_2_0");
+					put(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0(), "rule__XVariableDeclaration__WriteableAssignment_1_0");
+					put(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0(), "rule__XVariableDeclaration__TypeAssignment_2_0_0_0");
+					put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1(), "rule__XVariableDeclaration__NameAssignment_2_0_0_1");
+					put(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1(), "rule__XVariableDeclaration__NameAssignment_2_1");
+					put(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1(), "rule__XVariableDeclaration__RightAssignment_3_1");
+					put(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__JvmFormalParameter__ParameterTypeAssignment_0");
+					put(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1(), "rule__JvmFormalParameter__NameAssignment_1");
+					put(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0(), "rule__FullJvmFormalParameter__ParameterTypeAssignment_0");
+					put(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1(), "rule__FullJvmFormalParameter__NameAssignment_1");
+					put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_1");
+					put(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1(), "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1");
+					put(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2(), "rule__XFeatureCall__FeatureAssignment_2");
+					put(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0(), "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0");
+					put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0");
+					put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0");
+					put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1");
+					put(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4(), "rule__XFeatureCall__FeatureCallArgumentsAssignment_4");
+					put(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2(), "rule__XConstructorCall__ConstructorAssignment_2");
+					put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_1");
+					put(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1(), "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1");
+					put(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0(), "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0");
+					put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_0");
+					put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0");
+					put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1(), "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1");
+					put(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5(), "rule__XConstructorCall__ArgumentsAssignment_5");
+					put(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1(), "rule__XBooleanLiteral__IsTrueAssignment_1_1");
+					put(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1(), "rule__XNumberLiteral__ValueAssignment_1");
+					put(grammarAccess.getXStringLiteralAccess().getValueAssignment_1(), "rule__XStringLiteral__ValueAssignment_1");
+					put(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3(), "rule__XTypeLiteral__TypeAssignment_3");
+					put(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4(), "rule__XTypeLiteral__ArrayDimensionsAssignment_4");
+					put(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2(), "rule__XThrowExpression__ExpressionAssignment_2");
+					put(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2(), "rule__XReturnExpression__ExpressionAssignment_2");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2(), "rule__XTryCatchFinallyExpression__ExpressionAssignment_2");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0(), "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1");
+					put(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1(), "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1");
+					put(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1(), "rule__XSynchronizedExpression__ParamAssignment_1");
+					put(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3(), "rule__XSynchronizedExpression__ExpressionAssignment_3");
+					put(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2(), "rule__XCatchClause__DeclaredParamAssignment_2");
+					put(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4(), "rule__XCatchClause__ExpressionAssignment_4");
+					put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0");
+					put(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1(), "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1");
+					put(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2(), "rule__XFunctionTypeRef__ReturnTypeAssignment_2");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0(), "rule__JvmParameterizedTypeReference__TypeAssignment_0");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1(), "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1");
+					put(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1(), "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0");
+					put(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1(), "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1");
+					put(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBound__TypeReferenceAssignment_1");
+					put(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1");
+					put(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBound__TypeReferenceAssignment_1");
+					put(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1(), "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1");
+					put(grammarAccess.getJvmTypeParameterAccess().getNameAssignment_0(), "rule__JvmTypeParameter__NameAssignment_0");
+					put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_0(), "rule__JvmTypeParameter__ConstraintsAssignment_1_0");
+					put(grammarAccess.getJvmTypeParameterAccess().getConstraintsAssignment_1_1(), "rule__JvmTypeParameter__ConstraintsAssignment_1_1");
+					put(grammarAccess.getXImportSectionAccess().getImportDeclarationsAssignment(), "rule__XImportSection__ImportDeclarationsAssignment");
+				}
+			};
+		}
+		return nameMappings.get(element);
+	}
+			
+	@Override
+	protected String[] getInitialHiddenTokens() {
+		return new String[] { "RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT" };
+	}
+
+	public OXtypeGrammarAccess getGrammarAccess() {
+		return this.grammarAccess;
+	}
+
+	public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+		this.grammarAccess = grammarAccess;
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/PartialOXtypeContentAssistParser.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/PartialOXtypeContentAssistParser.java
new file mode 100644
index 0000000..adbfa4f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/PartialOXtypeContentAssistParser.java
@@ -0,0 +1,34 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr;
+
+import java.util.Collection;
+import java.util.Collections;
+import org.eclipse.xtext.AbstractRule;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.FollowElement;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.partialEditing.IPartialEditingContentAssistParser;
+import org.eclipse.xtext.util.PolymorphicDispatcher;
+
+public class PartialOXtypeContentAssistParser extends OXtypeParser implements IPartialEditingContentAssistParser {
+
+	private AbstractRule rule;
+
+	@Override
+	public void initializeFor(AbstractRule rule) {
+		this.rule = rule;
+	}
+
+	@Override
+	protected Collection<FollowElement> getFollowElements(AbstractInternalContentAssistParser parser) {
+		if (rule == null || rule.eIsProxy())
+			return Collections.emptyList();
+		String methodName = "entryRule" + rule.getName();
+		PolymorphicDispatcher<Collection<FollowElement>> dispatcher = 
+			new PolymorphicDispatcher<Collection<FollowElement>>(methodName, 0, 0, Collections.singletonList(parser));
+		dispatcher.invoke();
+		return parser.getFollowElements();
+	}
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.g b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.g
new file mode 100644
index 0000000..f84a267
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.g
@@ -0,0 +1,18614 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+grammar InternalOXtype;
+
+options {
+	superClass=AbstractInternalContentAssistParser;
+	backtrack=true;
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import. 
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+}
+@parser::members {
+	private OXtypeGrammarAccess grammarAccess;
+
+	public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+		this.grammarAccess = grammarAccess;
+	}
+
+	@Override
+	protected Grammar getGrammar() {
+		return grammarAccess.getGrammar();
+	}
+
+	@Override
+	protected String getValueForTokenName(String tokenName) {
+		return tokenName;
+	}
+}
+
+// Entry rule entryRuleXImportDeclaration
+entryRuleXImportDeclaration
+:
+{ before(grammarAccess.getXImportDeclarationRule()); }
+	 ruleXImportDeclaration
+{ after(grammarAccess.getXImportDeclarationRule()); } 
+	 EOF 
+;
+
+// Rule XImportDeclaration
+ruleXImportDeclaration 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+		(rule__XImportDeclaration__Group__0)
+		{ after(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotation
+entryRuleXAnnotation
+:
+{ before(grammarAccess.getXAnnotationRule()); }
+	 ruleXAnnotation
+{ after(grammarAccess.getXAnnotationRule()); } 
+	 EOF 
+;
+
+// Rule XAnnotation
+ruleXAnnotation 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getGroup()); }
+		(rule__XAnnotation__Group__0)
+		{ after(grammarAccess.getXAnnotationAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationElementValuePair
+entryRuleXAnnotationElementValuePair
+:
+{ before(grammarAccess.getXAnnotationElementValuePairRule()); }
+	 ruleXAnnotationElementValuePair
+{ after(grammarAccess.getXAnnotationElementValuePairRule()); } 
+	 EOF 
+;
+
+// Rule XAnnotationElementValuePair
+ruleXAnnotationElementValuePair 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
+		(rule__XAnnotationElementValuePair__Group__0)
+		{ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationElementValueOrCommaList
+entryRuleXAnnotationElementValueOrCommaList
+:
+{ before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+	 ruleXAnnotationElementValueOrCommaList
+{ after(grammarAccess.getXAnnotationElementValueOrCommaListRule()); } 
+	 EOF 
+;
+
+// Rule XAnnotationElementValueOrCommaList
+ruleXAnnotationElementValueOrCommaList 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
+		(rule__XAnnotationElementValueOrCommaList__Alternatives)
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationElementValue
+entryRuleXAnnotationElementValue
+:
+{ before(grammarAccess.getXAnnotationElementValueRule()); }
+	 ruleXAnnotationElementValue
+{ after(grammarAccess.getXAnnotationElementValueRule()); } 
+	 EOF 
+;
+
+// Rule XAnnotationElementValue
+ruleXAnnotationElementValue 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
+		(rule__XAnnotationElementValue__Alternatives)
+		{ after(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAnnotationOrExpression
+entryRuleXAnnotationOrExpression
+:
+{ before(grammarAccess.getXAnnotationOrExpressionRule()); }
+	 ruleXAnnotationOrExpression
+{ after(grammarAccess.getXAnnotationOrExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XAnnotationOrExpression
+ruleXAnnotationOrExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
+		(rule__XAnnotationOrExpression__Alternatives)
+		{ after(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXExpression
+entryRuleXExpression
+:
+{ before(grammarAccess.getXExpressionRule()); }
+	 ruleXExpression
+{ after(grammarAccess.getXExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XExpression
+ruleXExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
+		ruleXAssignment
+		{ after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAssignment
+entryRuleXAssignment
+:
+{ before(grammarAccess.getXAssignmentRule()); }
+	 ruleXAssignment
+{ after(grammarAccess.getXAssignmentRule()); } 
+	 EOF 
+;
+
+// Rule XAssignment
+ruleXAssignment 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getAlternatives()); }
+		(rule__XAssignment__Alternatives)
+		{ after(grammarAccess.getXAssignmentAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpSingleAssign
+entryRuleOpSingleAssign
+:
+{ before(grammarAccess.getOpSingleAssignRule()); }
+	 ruleOpSingleAssign
+{ after(grammarAccess.getOpSingleAssignRule()); } 
+	 EOF 
+;
+
+// Rule OpSingleAssign
+ruleOpSingleAssign 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
+		'='
+		{ after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpMultiAssign
+entryRuleOpMultiAssign
+:
+{ before(grammarAccess.getOpMultiAssignRule()); }
+	 ruleOpMultiAssign
+{ after(grammarAccess.getOpMultiAssignRule()); } 
+	 EOF 
+;
+
+// Rule OpMultiAssign
+ruleOpMultiAssign 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
+		(rule__OpMultiAssign__Alternatives)
+		{ after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXOrExpression
+entryRuleXOrExpression
+:
+{ before(grammarAccess.getXOrExpressionRule()); }
+	 ruleXOrExpression
+{ after(grammarAccess.getXOrExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XOrExpression
+ruleXOrExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXOrExpressionAccess().getGroup()); }
+		(rule__XOrExpression__Group__0)
+		{ after(grammarAccess.getXOrExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpOr
+entryRuleOpOr
+:
+{ before(grammarAccess.getOpOrRule()); }
+	 ruleOpOr
+{ after(grammarAccess.getOpOrRule()); } 
+	 EOF 
+;
+
+// Rule OpOr
+ruleOpOr 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
+		'||'
+		{ after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAndExpression
+entryRuleXAndExpression
+:
+{ before(grammarAccess.getXAndExpressionRule()); }
+	 ruleXAndExpression
+{ after(grammarAccess.getXAndExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XAndExpression
+ruleXAndExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAndExpressionAccess().getGroup()); }
+		(rule__XAndExpression__Group__0)
+		{ after(grammarAccess.getXAndExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpAnd
+entryRuleOpAnd
+:
+{ before(grammarAccess.getOpAndRule()); }
+	 ruleOpAnd
+{ after(grammarAccess.getOpAndRule()); } 
+	 EOF 
+;
+
+// Rule OpAnd
+ruleOpAnd 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
+		'&&'
+		{ after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXEqualityExpression
+entryRuleXEqualityExpression
+:
+{ before(grammarAccess.getXEqualityExpressionRule()); }
+	 ruleXEqualityExpression
+{ after(grammarAccess.getXEqualityExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XEqualityExpression
+ruleXEqualityExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
+		(rule__XEqualityExpression__Group__0)
+		{ after(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpEquality
+entryRuleOpEquality
+:
+{ before(grammarAccess.getOpEqualityRule()); }
+	 ruleOpEquality
+{ after(grammarAccess.getOpEqualityRule()); } 
+	 EOF 
+;
+
+// Rule OpEquality
+ruleOpEquality 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpEqualityAccess().getAlternatives()); }
+		(rule__OpEquality__Alternatives)
+		{ after(grammarAccess.getOpEqualityAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXRelationalExpression
+entryRuleXRelationalExpression
+:
+{ before(grammarAccess.getXRelationalExpressionRule()); }
+	 ruleXRelationalExpression
+{ after(grammarAccess.getXRelationalExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XRelationalExpression
+ruleXRelationalExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
+		(rule__XRelationalExpression__Group__0)
+		{ after(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpCompare
+entryRuleOpCompare
+:
+{ before(grammarAccess.getOpCompareRule()); }
+	 ruleOpCompare
+{ after(grammarAccess.getOpCompareRule()); } 
+	 EOF 
+;
+
+// Rule OpCompare
+ruleOpCompare 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpCompareAccess().getAlternatives()); }
+		(rule__OpCompare__Alternatives)
+		{ after(grammarAccess.getOpCompareAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXOtherOperatorExpression
+entryRuleXOtherOperatorExpression
+:
+{ before(grammarAccess.getXOtherOperatorExpressionRule()); }
+	 ruleXOtherOperatorExpression
+{ after(grammarAccess.getXOtherOperatorExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XOtherOperatorExpression
+ruleXOtherOperatorExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
+		(rule__XOtherOperatorExpression__Group__0)
+		{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpOther
+entryRuleOpOther
+:
+{ before(grammarAccess.getOpOtherRule()); }
+	 ruleOpOther
+{ after(grammarAccess.getOpOtherRule()); } 
+	 EOF 
+;
+
+// Rule OpOther
+ruleOpOther 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpOtherAccess().getAlternatives()); }
+		(rule__OpOther__Alternatives)
+		{ after(grammarAccess.getOpOtherAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXAdditiveExpression
+entryRuleXAdditiveExpression
+:
+{ before(grammarAccess.getXAdditiveExpressionRule()); }
+	 ruleXAdditiveExpression
+{ after(grammarAccess.getXAdditiveExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XAdditiveExpression
+ruleXAdditiveExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
+		(rule__XAdditiveExpression__Group__0)
+		{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpAdd
+entryRuleOpAdd
+:
+{ before(grammarAccess.getOpAddRule()); }
+	 ruleOpAdd
+{ after(grammarAccess.getOpAddRule()); } 
+	 EOF 
+;
+
+// Rule OpAdd
+ruleOpAdd 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpAddAccess().getAlternatives()); }
+		(rule__OpAdd__Alternatives)
+		{ after(grammarAccess.getOpAddAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXMultiplicativeExpression
+entryRuleXMultiplicativeExpression
+:
+{ before(grammarAccess.getXMultiplicativeExpressionRule()); }
+	 ruleXMultiplicativeExpression
+{ after(grammarAccess.getXMultiplicativeExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XMultiplicativeExpression
+ruleXMultiplicativeExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
+		(rule__XMultiplicativeExpression__Group__0)
+		{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpMulti
+entryRuleOpMulti
+:
+{ before(grammarAccess.getOpMultiRule()); }
+	 ruleOpMulti
+{ after(grammarAccess.getOpMultiRule()); } 
+	 EOF 
+;
+
+// Rule OpMulti
+ruleOpMulti 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpMultiAccess().getAlternatives()); }
+		(rule__OpMulti__Alternatives)
+		{ after(grammarAccess.getOpMultiAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXUnaryOperation
+entryRuleXUnaryOperation
+:
+{ before(grammarAccess.getXUnaryOperationRule()); }
+	 ruleXUnaryOperation
+{ after(grammarAccess.getXUnaryOperationRule()); } 
+	 EOF 
+;
+
+// Rule XUnaryOperation
+ruleXUnaryOperation 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
+		(rule__XUnaryOperation__Alternatives)
+		{ after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpUnary
+entryRuleOpUnary
+:
+{ before(grammarAccess.getOpUnaryRule()); }
+	 ruleOpUnary
+{ after(grammarAccess.getOpUnaryRule()); } 
+	 EOF 
+;
+
+// Rule OpUnary
+ruleOpUnary 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpUnaryAccess().getAlternatives()); }
+		(rule__OpUnary__Alternatives)
+		{ after(grammarAccess.getOpUnaryAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCastedExpression
+entryRuleXCastedExpression
+:
+{ before(grammarAccess.getXCastedExpressionRule()); }
+	 ruleXCastedExpression
+{ after(grammarAccess.getXCastedExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XCastedExpression
+ruleXCastedExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXCastedExpressionAccess().getGroup()); }
+		(rule__XCastedExpression__Group__0)
+		{ after(grammarAccess.getXCastedExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXPostfixOperation
+entryRuleXPostfixOperation
+:
+{ before(grammarAccess.getXPostfixOperationRule()); }
+	 ruleXPostfixOperation
+{ after(grammarAccess.getXPostfixOperationRule()); } 
+	 EOF 
+;
+
+// Rule XPostfixOperation
+ruleXPostfixOperation 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXPostfixOperationAccess().getGroup()); }
+		(rule__XPostfixOperation__Group__0)
+		{ after(grammarAccess.getXPostfixOperationAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleOpPostfix
+entryRuleOpPostfix
+:
+{ before(grammarAccess.getOpPostfixRule()); }
+	 ruleOpPostfix
+{ after(grammarAccess.getOpPostfixRule()); } 
+	 EOF 
+;
+
+// Rule OpPostfix
+ruleOpPostfix 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getOpPostfixAccess().getAlternatives()); }
+		(rule__OpPostfix__Alternatives)
+		{ after(grammarAccess.getOpPostfixAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXMemberFeatureCall
+entryRuleXMemberFeatureCall
+:
+{ before(grammarAccess.getXMemberFeatureCallRule()); }
+	 ruleXMemberFeatureCall
+{ after(grammarAccess.getXMemberFeatureCallRule()); } 
+	 EOF 
+;
+
+// Rule XMemberFeatureCall
+ruleXMemberFeatureCall 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
+		(rule__XMemberFeatureCall__Group__0)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXPrimaryExpression
+entryRuleXPrimaryExpression
+:
+{ before(grammarAccess.getXPrimaryExpressionRule()); }
+	 ruleXPrimaryExpression
+{ after(grammarAccess.getXPrimaryExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XPrimaryExpression
+ruleXPrimaryExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
+		(rule__XPrimaryExpression__Alternatives)
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXLiteral
+entryRuleXLiteral
+:
+{ before(grammarAccess.getXLiteralRule()); }
+	 ruleXLiteral
+{ after(grammarAccess.getXLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XLiteral
+ruleXLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXLiteralAccess().getAlternatives()); }
+		(rule__XLiteral__Alternatives)
+		{ after(grammarAccess.getXLiteralAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCollectionLiteral
+entryRuleXCollectionLiteral
+:
+{ before(grammarAccess.getXCollectionLiteralRule()); }
+	 ruleXCollectionLiteral
+{ after(grammarAccess.getXCollectionLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XCollectionLiteral
+ruleXCollectionLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
+		(rule__XCollectionLiteral__Alternatives)
+		{ after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXSetLiteral
+entryRuleXSetLiteral
+:
+{ before(grammarAccess.getXSetLiteralRule()); }
+	 ruleXSetLiteral
+{ after(grammarAccess.getXSetLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XSetLiteral
+ruleXSetLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXSetLiteralAccess().getGroup()); }
+		(rule__XSetLiteral__Group__0)
+		{ after(grammarAccess.getXSetLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXListLiteral
+entryRuleXListLiteral
+:
+{ before(grammarAccess.getXListLiteralRule()); }
+	 ruleXListLiteral
+{ after(grammarAccess.getXListLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XListLiteral
+ruleXListLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXListLiteralAccess().getGroup()); }
+		(rule__XListLiteral__Group__0)
+		{ after(grammarAccess.getXListLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXClosure
+entryRuleXClosure
+:
+{ before(grammarAccess.getXClosureRule()); }
+	 ruleXClosure
+{ after(grammarAccess.getXClosureRule()); } 
+	 EOF 
+;
+
+// Rule XClosure
+ruleXClosure 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXClosureAccess().getGroup()); }
+		(rule__XClosure__Group__0)
+		{ after(grammarAccess.getXClosureAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXExpressionInClosure
+entryRuleXExpressionInClosure
+:
+{ before(grammarAccess.getXExpressionInClosureRule()); }
+	 ruleXExpressionInClosure
+{ after(grammarAccess.getXExpressionInClosureRule()); } 
+	 EOF 
+;
+
+// Rule XExpressionInClosure
+ruleXExpressionInClosure 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
+		(rule__XExpressionInClosure__Group__0)
+		{ after(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXShortClosure
+entryRuleXShortClosure
+:
+{ before(grammarAccess.getXShortClosureRule()); }
+	 ruleXShortClosure
+{ after(grammarAccess.getXShortClosureRule()); } 
+	 EOF 
+;
+
+// Rule XShortClosure
+ruleXShortClosure 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXShortClosureAccess().getGroup()); }
+		(rule__XShortClosure__Group__0)
+		{ after(grammarAccess.getXShortClosureAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXParenthesizedExpression
+entryRuleXParenthesizedExpression
+:
+{ before(grammarAccess.getXParenthesizedExpressionRule()); }
+	 ruleXParenthesizedExpression
+{ after(grammarAccess.getXParenthesizedExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XParenthesizedExpression
+ruleXParenthesizedExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
+		(rule__XParenthesizedExpression__Group__0)
+		{ after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXIfExpression
+entryRuleXIfExpression
+:
+{ before(grammarAccess.getXIfExpressionRule()); }
+	 ruleXIfExpression
+{ after(grammarAccess.getXIfExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XIfExpression
+ruleXIfExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXIfExpressionAccess().getGroup()); }
+		(rule__XIfExpression__Group__0)
+		{ after(grammarAccess.getXIfExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXSwitchExpression
+entryRuleXSwitchExpression
+:
+{ before(grammarAccess.getXSwitchExpressionRule()); }
+	 ruleXSwitchExpression
+{ after(grammarAccess.getXSwitchExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XSwitchExpression
+ruleXSwitchExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
+		(rule__XSwitchExpression__Group__0)
+		{ after(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCasePart
+entryRuleXCasePart
+:
+{ before(grammarAccess.getXCasePartRule()); }
+	 ruleXCasePart
+{ after(grammarAccess.getXCasePartRule()); } 
+	 EOF 
+;
+
+// Rule XCasePart
+ruleXCasePart 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXCasePartAccess().getGroup()); }
+		(rule__XCasePart__Group__0)
+		{ after(grammarAccess.getXCasePartAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXForLoopExpression
+entryRuleXForLoopExpression
+:
+{ before(grammarAccess.getXForLoopExpressionRule()); }
+	 ruleXForLoopExpression
+{ after(grammarAccess.getXForLoopExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XForLoopExpression
+ruleXForLoopExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
+		(rule__XForLoopExpression__Group__0)
+		{ after(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXBasicForLoopExpression
+entryRuleXBasicForLoopExpression
+:
+{ before(grammarAccess.getXBasicForLoopExpressionRule()); }
+	 ruleXBasicForLoopExpression
+{ after(grammarAccess.getXBasicForLoopExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XBasicForLoopExpression
+ruleXBasicForLoopExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
+		(rule__XBasicForLoopExpression__Group__0)
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXWhileExpression
+entryRuleXWhileExpression
+:
+{ before(grammarAccess.getXWhileExpressionRule()); }
+	 ruleXWhileExpression
+{ after(grammarAccess.getXWhileExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XWhileExpression
+ruleXWhileExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXWhileExpressionAccess().getGroup()); }
+		(rule__XWhileExpression__Group__0)
+		{ after(grammarAccess.getXWhileExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXDoWhileExpression
+entryRuleXDoWhileExpression
+:
+{ before(grammarAccess.getXDoWhileExpressionRule()); }
+	 ruleXDoWhileExpression
+{ after(grammarAccess.getXDoWhileExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XDoWhileExpression
+ruleXDoWhileExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
+		(rule__XDoWhileExpression__Group__0)
+		{ after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXBlockExpression
+entryRuleXBlockExpression
+:
+{ before(grammarAccess.getXBlockExpressionRule()); }
+	 ruleXBlockExpression
+{ after(grammarAccess.getXBlockExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XBlockExpression
+ruleXBlockExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXBlockExpressionAccess().getGroup()); }
+		(rule__XBlockExpression__Group__0)
+		{ after(grammarAccess.getXBlockExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXExpressionOrVarDeclaration
+entryRuleXExpressionOrVarDeclaration
+:
+{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+	 ruleXExpressionOrVarDeclaration
+{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); } 
+	 EOF 
+;
+
+// Rule XExpressionOrVarDeclaration
+ruleXExpressionOrVarDeclaration 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
+		(rule__XExpressionOrVarDeclaration__Alternatives)
+		{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXVariableDeclaration
+entryRuleXVariableDeclaration
+:
+{ before(grammarAccess.getXVariableDeclarationRule()); }
+	 ruleXVariableDeclaration
+{ after(grammarAccess.getXVariableDeclarationRule()); } 
+	 EOF 
+;
+
+// Rule XVariableDeclaration
+ruleXVariableDeclaration 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
+		(rule__XVariableDeclaration__Group__0)
+		{ after(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmFormalParameter
+entryRuleJvmFormalParameter
+:
+{ before(grammarAccess.getJvmFormalParameterRule()); }
+	 ruleJvmFormalParameter
+{ after(grammarAccess.getJvmFormalParameterRule()); } 
+	 EOF 
+;
+
+// Rule JvmFormalParameter
+ruleJvmFormalParameter 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
+		(rule__JvmFormalParameter__Group__0)
+		{ after(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleFullJvmFormalParameter
+entryRuleFullJvmFormalParameter
+:
+{ before(grammarAccess.getFullJvmFormalParameterRule()); }
+	 ruleFullJvmFormalParameter
+{ after(grammarAccess.getFullJvmFormalParameterRule()); } 
+	 EOF 
+;
+
+// Rule FullJvmFormalParameter
+ruleFullJvmFormalParameter 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
+		(rule__FullJvmFormalParameter__Group__0)
+		{ after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXFeatureCall
+entryRuleXFeatureCall
+:
+{ before(grammarAccess.getXFeatureCallRule()); }
+	 ruleXFeatureCall
+{ after(grammarAccess.getXFeatureCallRule()); } 
+	 EOF 
+;
+
+// Rule XFeatureCall
+ruleXFeatureCall 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getGroup()); }
+		(rule__XFeatureCall__Group__0)
+		{ after(grammarAccess.getXFeatureCallAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleFeatureCallID
+entryRuleFeatureCallID
+:
+{ before(grammarAccess.getFeatureCallIDRule()); }
+	 ruleFeatureCallID
+{ after(grammarAccess.getFeatureCallIDRule()); } 
+	 EOF 
+;
+
+// Rule FeatureCallID
+ruleFeatureCallID 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
+		(rule__FeatureCallID__Alternatives)
+		{ after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleIdOrSuper
+entryRuleIdOrSuper
+:
+{ before(grammarAccess.getIdOrSuperRule()); }
+	 ruleIdOrSuper
+{ after(grammarAccess.getIdOrSuperRule()); } 
+	 EOF 
+;
+
+// Rule IdOrSuper
+ruleIdOrSuper 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
+		(rule__IdOrSuper__Alternatives)
+		{ after(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXConstructorCall
+entryRuleXConstructorCall
+:
+{ before(grammarAccess.getXConstructorCallRule()); }
+	 ruleXConstructorCall
+{ after(grammarAccess.getXConstructorCallRule()); } 
+	 EOF 
+;
+
+// Rule XConstructorCall
+ruleXConstructorCall 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getGroup()); }
+		(rule__XConstructorCall__Group__0)
+		{ after(grammarAccess.getXConstructorCallAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXBooleanLiteral
+entryRuleXBooleanLiteral
+:
+{ before(grammarAccess.getXBooleanLiteralRule()); }
+	 ruleXBooleanLiteral
+{ after(grammarAccess.getXBooleanLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XBooleanLiteral
+ruleXBooleanLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
+		(rule__XBooleanLiteral__Group__0)
+		{ after(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXNullLiteral
+entryRuleXNullLiteral
+:
+{ before(grammarAccess.getXNullLiteralRule()); }
+	 ruleXNullLiteral
+{ after(grammarAccess.getXNullLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XNullLiteral
+ruleXNullLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXNullLiteralAccess().getGroup()); }
+		(rule__XNullLiteral__Group__0)
+		{ after(grammarAccess.getXNullLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXNumberLiteral
+entryRuleXNumberLiteral
+:
+{ before(grammarAccess.getXNumberLiteralRule()); }
+	 ruleXNumberLiteral
+{ after(grammarAccess.getXNumberLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XNumberLiteral
+ruleXNumberLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXNumberLiteralAccess().getGroup()); }
+		(rule__XNumberLiteral__Group__0)
+		{ after(grammarAccess.getXNumberLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXStringLiteral
+entryRuleXStringLiteral
+:
+{ before(grammarAccess.getXStringLiteralRule()); }
+	 ruleXStringLiteral
+{ after(grammarAccess.getXStringLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XStringLiteral
+ruleXStringLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXStringLiteralAccess().getGroup()); }
+		(rule__XStringLiteral__Group__0)
+		{ after(grammarAccess.getXStringLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXTypeLiteral
+entryRuleXTypeLiteral
+:
+{ before(grammarAccess.getXTypeLiteralRule()); }
+	 ruleXTypeLiteral
+{ after(grammarAccess.getXTypeLiteralRule()); } 
+	 EOF 
+;
+
+// Rule XTypeLiteral
+ruleXTypeLiteral 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXTypeLiteralAccess().getGroup()); }
+		(rule__XTypeLiteral__Group__0)
+		{ after(grammarAccess.getXTypeLiteralAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXThrowExpression
+entryRuleXThrowExpression
+:
+{ before(grammarAccess.getXThrowExpressionRule()); }
+	 ruleXThrowExpression
+{ after(grammarAccess.getXThrowExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XThrowExpression
+ruleXThrowExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXThrowExpressionAccess().getGroup()); }
+		(rule__XThrowExpression__Group__0)
+		{ after(grammarAccess.getXThrowExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXReturnExpression
+entryRuleXReturnExpression
+:
+{ before(grammarAccess.getXReturnExpressionRule()); }
+	 ruleXReturnExpression
+{ after(grammarAccess.getXReturnExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XReturnExpression
+ruleXReturnExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXReturnExpressionAccess().getGroup()); }
+		(rule__XReturnExpression__Group__0)
+		{ after(grammarAccess.getXReturnExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXTryCatchFinallyExpression
+entryRuleXTryCatchFinallyExpression
+:
+{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+	 ruleXTryCatchFinallyExpression
+{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XTryCatchFinallyExpression
+ruleXTryCatchFinallyExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
+		(rule__XTryCatchFinallyExpression__Group__0)
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXSynchronizedExpression
+entryRuleXSynchronizedExpression
+:
+{ before(grammarAccess.getXSynchronizedExpressionRule()); }
+	 ruleXSynchronizedExpression
+{ after(grammarAccess.getXSynchronizedExpressionRule()); } 
+	 EOF 
+;
+
+// Rule XSynchronizedExpression
+ruleXSynchronizedExpression 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
+		(rule__XSynchronizedExpression__Group__0)
+		{ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXCatchClause
+entryRuleXCatchClause
+:
+{ before(grammarAccess.getXCatchClauseRule()); }
+	 ruleXCatchClause
+{ after(grammarAccess.getXCatchClauseRule()); } 
+	 EOF 
+;
+
+// Rule XCatchClause
+ruleXCatchClause 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXCatchClauseAccess().getGroup()); }
+		(rule__XCatchClause__Group__0)
+		{ after(grammarAccess.getXCatchClauseAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName
+:
+{ before(grammarAccess.getQualifiedNameRule()); }
+	 ruleQualifiedName
+{ after(grammarAccess.getQualifiedNameRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedName
+ruleQualifiedName 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getQualifiedNameAccess().getGroup()); }
+		(rule__QualifiedName__Group__0)
+		{ after(grammarAccess.getQualifiedNameAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleNumber
+entryRuleNumber
+@init { 
+	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}
+:
+{ before(grammarAccess.getNumberRule()); }
+	 ruleNumber
+{ after(grammarAccess.getNumberRule()); } 
+	 EOF 
+;
+finally {
+	myHiddenTokenState.restore();
+}
+
+// Rule Number
+ruleNumber 
+	@init {
+		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getNumberAccess().getAlternatives()); }
+		(rule__Number__Alternatives)
+		{ after(grammarAccess.getNumberAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+	myHiddenTokenState.restore();
+}
+
+// Entry rule entryRuleJvmTypeReference
+entryRuleJvmTypeReference
+:
+{ before(grammarAccess.getJvmTypeReferenceRule()); }
+	 ruleJvmTypeReference
+{ after(grammarAccess.getJvmTypeReferenceRule()); } 
+	 EOF 
+;
+
+// Rule JvmTypeReference
+ruleJvmTypeReference 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
+		(rule__JvmTypeReference__Alternatives)
+		{ after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleArrayBrackets
+entryRuleArrayBrackets
+:
+{ before(grammarAccess.getArrayBracketsRule()); }
+	 ruleArrayBrackets
+{ after(grammarAccess.getArrayBracketsRule()); } 
+	 EOF 
+;
+
+// Rule ArrayBrackets
+ruleArrayBrackets 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getArrayBracketsAccess().getGroup()); }
+		(rule__ArrayBrackets__Group__0)
+		{ after(grammarAccess.getArrayBracketsAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleXFunctionTypeRef
+entryRuleXFunctionTypeRef
+:
+{ before(grammarAccess.getXFunctionTypeRefRule()); }
+	 ruleXFunctionTypeRef
+{ after(grammarAccess.getXFunctionTypeRefRule()); } 
+	 EOF 
+;
+
+// Rule XFunctionTypeRef
+ruleXFunctionTypeRef 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
+		(rule__XFunctionTypeRef__Group__0)
+		{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmParameterizedTypeReference
+entryRuleJvmParameterizedTypeReference
+:
+{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+	 ruleJvmParameterizedTypeReference
+{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); } 
+	 EOF 
+;
+
+// Rule JvmParameterizedTypeReference
+ruleJvmParameterizedTypeReference 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
+		(rule__JvmParameterizedTypeReference__Group__0)
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmArgumentTypeReference
+entryRuleJvmArgumentTypeReference
+:
+{ before(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+	 ruleJvmArgumentTypeReference
+{ after(grammarAccess.getJvmArgumentTypeReferenceRule()); } 
+	 EOF 
+;
+
+// Rule JvmArgumentTypeReference
+ruleJvmArgumentTypeReference 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
+		(rule__JvmArgumentTypeReference__Alternatives)
+		{ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmWildcardTypeReference
+entryRuleJvmWildcardTypeReference
+:
+{ before(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+	 ruleJvmWildcardTypeReference
+{ after(grammarAccess.getJvmWildcardTypeReferenceRule()); } 
+	 EOF 
+;
+
+// Rule JvmWildcardTypeReference
+ruleJvmWildcardTypeReference 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
+		(rule__JvmWildcardTypeReference__Group__0)
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmUpperBound
+entryRuleJvmUpperBound
+:
+{ before(grammarAccess.getJvmUpperBoundRule()); }
+	 ruleJvmUpperBound
+{ after(grammarAccess.getJvmUpperBoundRule()); } 
+	 EOF 
+;
+
+// Rule JvmUpperBound
+ruleJvmUpperBound 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
+		(rule__JvmUpperBound__Group__0)
+		{ after(grammarAccess.getJvmUpperBoundAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmUpperBoundAnded
+entryRuleJvmUpperBoundAnded
+:
+{ before(grammarAccess.getJvmUpperBoundAndedRule()); }
+	 ruleJvmUpperBoundAnded
+{ after(grammarAccess.getJvmUpperBoundAndedRule()); } 
+	 EOF 
+;
+
+// Rule JvmUpperBoundAnded
+ruleJvmUpperBoundAnded 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
+		(rule__JvmUpperBoundAnded__Group__0)
+		{ after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmLowerBound
+entryRuleJvmLowerBound
+:
+{ before(grammarAccess.getJvmLowerBoundRule()); }
+	 ruleJvmLowerBound
+{ after(grammarAccess.getJvmLowerBoundRule()); } 
+	 EOF 
+;
+
+// Rule JvmLowerBound
+ruleJvmLowerBound 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
+		(rule__JvmLowerBound__Group__0)
+		{ after(grammarAccess.getJvmLowerBoundAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleJvmLowerBoundAnded
+entryRuleJvmLowerBoundAnded
+:
+{ before(grammarAccess.getJvmLowerBoundAndedRule()); }
+	 ruleJvmLowerBoundAnded
+{ after(grammarAccess.getJvmLowerBoundAndedRule()); } 
+	 EOF 
+;
+
+// Rule JvmLowerBoundAnded
+ruleJvmLowerBoundAnded 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
+		(rule__JvmLowerBoundAnded__Group__0)
+		{ after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleQualifiedNameWithWildcard
+entryRuleQualifiedNameWithWildcard
+:
+{ before(grammarAccess.getQualifiedNameWithWildcardRule()); }
+	 ruleQualifiedNameWithWildcard
+{ after(grammarAccess.getQualifiedNameWithWildcardRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedNameWithWildcard
+ruleQualifiedNameWithWildcard 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
+		(rule__QualifiedNameWithWildcard__Group__0)
+		{ after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleValidID
+entryRuleValidID
+:
+{ before(grammarAccess.getValidIDRule()); }
+	 ruleValidID
+{ after(grammarAccess.getValidIDRule()); } 
+	 EOF 
+;
+
+// Rule ValidID
+ruleValidID 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		{ before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
+		RULE_ID
+		{ after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+// Entry rule entryRuleQualifiedNameInStaticImport
+entryRuleQualifiedNameInStaticImport
+:
+{ before(grammarAccess.getQualifiedNameInStaticImportRule()); }
+	 ruleQualifiedNameInStaticImport
+{ after(grammarAccess.getQualifiedNameInStaticImportRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedNameInStaticImport
+ruleQualifiedNameInStaticImport 
+	@init {
+		int stackSize = keepStackSize();
+	}
+	:
+	(
+		(
+			{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+			(rule__QualifiedNameInStaticImport__Group__0)
+			{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+		)
+		(
+			{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+			(rule__QualifiedNameInStaticImport__Group__0)*
+			{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+		)
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getGroup_2_0()); }
+		(rule__XImportDeclaration__Group_2_0__0)
+		{ after(grammarAccess.getXImportDeclarationAccess().getGroup_2_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1()); }
+		(rule__XImportDeclaration__ImportedTypeAssignment_2_1)
+		{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2()); }
+		(rule__XImportDeclaration__ImportedNamespaceAssignment_2_2)
+		{ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getGroup_2_3()); }
+		(rule__XImportDeclaration__Group_2_3__0)
+		{ after(grammarAccess.getXImportDeclarationAccess().getGroup_2_3()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_2_0_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0()); }
+		(rule__XImportDeclaration__WildcardAssignment_2_0_3_0)
+		{ after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1()); }
+		(rule__XImportDeclaration__MemberNameAssignment_2_0_3_1)
+		{ after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Alternatives_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
+		(rule__XAnnotation__Group_3_1_0__0)
+		{ after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
+		(rule__XAnnotation__ValueAssignment_3_1_1)
+		{ after(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
+		(rule__XAnnotationElementValueOrCommaList__Group_0__0)
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
+		(rule__XAnnotationElementValueOrCommaList__Group_1__0)
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
+		(rule__XAnnotationElementValue__Group_0__0)
+		{ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
+		ruleXAnnotationOrExpression
+		{ after(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationOrExpression__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
+		ruleXAnnotation
+		{ after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
+		ruleXExpression
+		{ after(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getGroup_0()); }
+		(rule__XAssignment__Group_0__0)
+		{ after(grammarAccess.getXAssignmentAccess().getGroup_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getGroup_1()); }
+		(rule__XAssignment__Group_1__0)
+		{ after(grammarAccess.getXAssignmentAccess().getGroup_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
+		'+='
+		{ after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
+		'-='
+		{ after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
+		'*='
+		{ after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
+		'/='
+		{ after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
+		'%='
+		{ after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
+		(rule__OpMultiAssign__Group_5__0)
+		{ after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
+		(rule__OpMultiAssign__Group_6__0)
+		{ after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpEquality__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
+		'=='
+		{ after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
+		'!='
+		{ after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
+		'==='
+		{ after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
+		'!=='
+		{ after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Alternatives_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
+		(rule__XRelationalExpression__Group_1_0__0)
+		{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
+		(rule__XRelationalExpression__Group_1_1__0)
+		{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
+		'>='
+		{ after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpCompareAccess().getGroup_1()); }
+		(rule__OpCompare__Group_1__0)
+		{ after(grammarAccess.getOpCompareAccess().getGroup_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
+		'>'
+		{ after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
+		'<'
+		{ after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+		'->'
+		{ after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
+		'..<'
+		{ after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getGroup_2()); }
+		(rule__OpOther__Group_2__0)
+		{ after(grammarAccess.getOpOtherAccess().getGroup_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
+		'..'
+		{ after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
+		'=>'
+		{ after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getGroup_5()); }
+		(rule__OpOther__Group_5__0)
+		{ after(grammarAccess.getOpOtherAccess().getGroup_5()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getGroup_6()); }
+		(rule__OpOther__Group_6__0)
+		{ after(grammarAccess.getOpOtherAccess().getGroup_6()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
+		'<>'
+		{ after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
+		'?:'
+		{ after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives_5_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
+		(rule__OpOther__Group_5_1_0__0)
+		{ after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
+		'>'
+		{ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Alternatives_6_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
+		(rule__OpOther__Group_6_1_0__0)
+		{ after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
+		'<'
+		{ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
+		'=>'
+		{ after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpAdd__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
+		'+'
+		{ after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
+		'-'
+		{ after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMulti__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
+		'*'
+		{ after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
+		'**'
+		{ after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
+		'/'
+		{ after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
+		'%'
+		{ after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
+		(rule__XUnaryOperation__Group_0__0)
+		{ after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
+		ruleXCastedExpression
+		{ after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpUnary__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
+		'!'
+		{ after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
+		'-'
+		{ after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
+		'+'
+		{ after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpPostfix__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
+		'++'
+		{ after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
+		'--'
+		{ after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
+		(rule__XMemberFeatureCall__Group_1_0__0)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
+		(rule__XMemberFeatureCall__Group_1_1__0)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_0_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
+		'.'
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
+		(rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
+		'.'
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
+		(rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
+		(rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Alternatives_1_1_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
+		(rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
+		(rule__XMemberFeatureCall__Group_1_1_3_1_1__0)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPrimaryExpression__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
+		ruleXConstructorCall
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
+		ruleXBlockExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
+		ruleXSwitchExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
+		(ruleXSynchronizedExpression)
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
+		ruleXFeatureCall
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
+		ruleXLiteral
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
+		ruleXIfExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
+		(ruleXForLoopExpression)
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); }
+		ruleXBasicForLoopExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); }
+		ruleXWhileExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); }
+		ruleXDoWhileExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); }
+		ruleXThrowExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); }
+		ruleXReturnExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); }
+		ruleXTryCatchFinallyExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); }
+		ruleXParenthesizedExpression
+		{ after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XLiteral__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); }
+		ruleXCollectionLiteral
+		{ after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); }
+		(ruleXClosure)
+		{ after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); }
+		ruleXBooleanLiteral
+		{ after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); }
+		ruleXNumberLiteral
+		{ after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); }
+		ruleXNullLiteral
+		{ after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); }
+		ruleXStringLiteral
+		{ after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); }
+		ruleXTypeLiteral
+		{ after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCollectionLiteral__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); }
+		ruleXSetLiteral
+		{ after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); }
+		ruleXListLiteral
+		{ after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Alternatives_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); }
+		(rule__XSwitchExpression__Group_2_0__0)
+		{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); }
+		(rule__XSwitchExpression__Group_2_1__0)
+		{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Alternatives_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCasePartAccess().getGroup_3_0()); }
+		(rule__XCasePart__Group_3_0__0)
+		{ after(grammarAccess.getXCasePartAccess().getGroup_3_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); }
+		(rule__XCasePart__FallThroughAssignment_3_1)
+		{ after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionOrVarDeclaration__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); }
+		ruleXVariableDeclaration
+		{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); }
+		ruleXExpression
+		{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Alternatives_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); }
+		(rule__XVariableDeclaration__WriteableAssignment_1_0)
+		{ after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); }
+		'val'
+		{ after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Alternatives_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); }
+		(rule__XVariableDeclaration__Group_2_0__0)
+		{ after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); }
+		(rule__XVariableDeclaration__NameAssignment_2_1)
+		{ after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Alternatives_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); }
+		(rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0)
+		{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); }
+		(rule__XFeatureCall__Group_3_1_1__0)
+		{ after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FeatureCallID__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); }
+		ruleValidID
+		{ after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); }
+		'extends'
+		{ after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); }
+		'static'
+		{ after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); }
+		'import'
+		{ after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); }
+		'extension'
+		{ after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__IdOrSuper__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); }
+		ruleFeatureCallID
+		{ after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); }
+		'super'
+		{ after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Alternatives_4_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); }
+		(rule__XConstructorCall__ArgumentsAssignment_4_1_0)
+		{ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); }
+		(rule__XConstructorCall__Group_4_1_1__0)
+		{ after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Alternatives_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); }
+		'false'
+		{ after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
+		(rule__XBooleanLiteral__IsTrueAssignment_1_1)
+		{ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Alternatives_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); }
+		(rule__XTryCatchFinallyExpression__Group_3_0__0)
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); }
+		(rule__XTryCatchFinallyExpression__Group_3_1__0)
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); }
+		RULE_HEX
+		{ after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getNumberAccess().getGroup_1()); }
+		(rule__Number__Group_1__0)
+		{ after(grammarAccess.getNumberAccess().getGroup_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); }
+		RULE_INT
+		{ after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); }
+		RULE_DECIMAL
+		{ after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Alternatives_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); }
+		RULE_INT
+		{ after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); }
+		RULE_DECIMAL
+		{ after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); }
+		(rule__JvmTypeReference__Group_0__0)
+		{ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); }
+		ruleXFunctionTypeRef
+		{ after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmArgumentTypeReference__Alternatives
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); }
+		ruleJvmWildcardTypeReference
+		{ after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Alternatives_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); }
+		(rule__JvmWildcardTypeReference__Group_2_0__0)
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); }
+	)
+	|
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); }
+		(rule__JvmWildcardTypeReference__Group_2_1__0)
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group__0__Impl
+	rule__XImportDeclaration__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0()); }
+	()
+	{ after(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group__1__Impl
+	rule__XImportDeclaration__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1()); }
+	'import'
+	{ after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group__2__Impl
+	rule__XImportDeclaration__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2()); }
+	(rule__XImportDeclaration__Alternatives_2)
+	{ after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3()); }
+	(';')?
+	{ after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XImportDeclaration__Group_2_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group_2_0__0__Impl
+	rule__XImportDeclaration__Group_2_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0()); }
+	(rule__XImportDeclaration__StaticAssignment_2_0_0)
+	{ after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group_2_0__1__Impl
+	rule__XImportDeclaration__Group_2_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1()); }
+	(rule__XImportDeclaration__ExtensionAssignment_2_0_1)?
+	{ after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group_2_0__2__Impl
+	rule__XImportDeclaration__Group_2_0__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2()); }
+	(rule__XImportDeclaration__ImportedTypeAssignment_2_0_2)
+	{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group_2_0__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_0__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3()); }
+	(rule__XImportDeclaration__Alternatives_2_0_3)
+	{ after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XImportDeclaration__Group_2_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group_2_3__0__Impl
+	rule__XImportDeclaration__Group_2_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0()); }
+	(rule__XImportDeclaration__FqnImportAssignment_2_3_0)
+	{ after(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XImportDeclaration__Group_2_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Group_2_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1()); }
+	(rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1)
+	{ after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group__0__Impl
+	rule__XAnnotation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0()); }
+	()
+	{ after(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group__1__Impl
+	rule__XAnnotation__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1()); }
+	'@'
+	{ after(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group__2__Impl
+	rule__XAnnotation__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2()); }
+	(rule__XAnnotation__AnnotationTypeAssignment_2)
+	{ after(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getGroup_3()); }
+	(rule__XAnnotation__Group_3__0)?
+	{ after(grammarAccess.getXAnnotationAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3__0__Impl
+	rule__XAnnotation__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()); }
+	('(')
+	{ after(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3__1__Impl
+	rule__XAnnotation__Group_3__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getAlternatives_3_1()); }
+	(rule__XAnnotation__Alternatives_3_1)?
+	{ after(grammarAccess.getXAnnotationAccess().getAlternatives_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()); }
+	')'
+	{ after(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group_3_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3_1_0__0__Impl
+	rule__XAnnotation__Group_3_1_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0()); }
+	(rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0)
+	{ after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3_1_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1()); }
+	(rule__XAnnotation__Group_3_1_0_1__0)*
+	{ after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotation__Group_3_1_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3_1_0_1__0__Impl
+	rule__XAnnotation__Group_3_1_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0()); }
+	','
+	{ after(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotation__Group_3_1_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__Group_3_1_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1()); }
+	(rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1)
+	{ after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValuePair__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValuePair__Group__0__Impl
+	rule__XAnnotationElementValuePair__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0()); }
+	(rule__XAnnotationElementValuePair__Group_0__0)
+	{ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValuePair__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1()); }
+	(rule__XAnnotationElementValuePair__ValueAssignment_1)
+	{ after(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValuePair__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValuePair__Group_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0()); }
+	(rule__XAnnotationElementValuePair__Group_0_0__0)
+	{ after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValuePair__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValuePair__Group_0_0__0__Impl
+	rule__XAnnotationElementValuePair__Group_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0()); }
+	(rule__XAnnotationElementValuePair__ElementAssignment_0_0_0)
+	{ after(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValuePair__Group_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__Group_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1()); }
+	'='
+	{ after(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0()); }
+	(rule__XAnnotationElementValueOrCommaList__Group_0_0__0)
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1()); }
+	(rule__XAnnotationElementValueOrCommaList__Group_0_1__0)?
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2()); }
+	']'
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0()); }
+	(rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0)
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0()); }
+	()
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1()); }
+	'#'
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+	'['
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0()); }
+	(rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0)
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1()); }
+	(rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0)*
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0()); }
+	','
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1()); }
+	(rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1)
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0()); }
+	ruleXAnnotationOrExpression
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1()); }
+	(rule__XAnnotationElementValueOrCommaList__Group_1_1__0)?
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()); }
+	()
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+		(rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0)
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+	)
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+		(rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0)*
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); }
+	)
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl
+	rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0()); }
+	','
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1()); }
+	(rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1)
+	{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0__0__Impl
+	rule__XAnnotationElementValue__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0()); }
+	(rule__XAnnotationElementValue__Group_0_0__0)
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0__1__Impl
+	rule__XAnnotationElementValue__Group_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1()); }
+	(rule__XAnnotationElementValue__Group_0_1__0)?
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2()); }
+	']'
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0()); }
+	(rule__XAnnotationElementValue__Group_0_0_0__0)
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_0_0__0__Impl
+	rule__XAnnotationElementValue__Group_0_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0()); }
+	()
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_0_0__1__Impl
+	rule__XAnnotationElementValue__Group_0_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1()); }
+	'#'
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_0_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+	'['
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_1__0__Impl
+	rule__XAnnotationElementValue__Group_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0()); }
+	(rule__XAnnotationElementValue__ElementsAssignment_0_1_0)
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1()); }
+	(rule__XAnnotationElementValue__Group_0_1_1__0)*
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAnnotationElementValue__Group_0_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_1_1__0__Impl
+	rule__XAnnotationElementValue__Group_0_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0()); }
+	','
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAnnotationElementValue__Group_0_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__Group_0_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1()); }
+	(rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1)
+	{ after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_0__0__Impl
+	rule__XAssignment__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); }
+	()
+	{ after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_0__1__Impl
+	rule__XAssignment__Group_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); }
+	(rule__XAssignment__FeatureAssignment_0_1)
+	{ after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_0__2__Impl
+	rule__XAssignment__Group_0__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); }
+	ruleOpSingleAssign
+	{ after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_0__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_0__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); }
+	(rule__XAssignment__ValueAssignment_0_3)
+	{ after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1__0__Impl
+	rule__XAssignment__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); }
+	ruleXOrExpression
+	{ after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); }
+	(rule__XAssignment__Group_1_1__0)?
+	{ after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1_1__0__Impl
+	rule__XAssignment__Group_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); }
+	(rule__XAssignment__Group_1_1_0__0)
+	{ after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); }
+	(rule__XAssignment__RightOperandAssignment_1_1_1)
+	{ after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); }
+	(rule__XAssignment__Group_1_1_0_0__0)
+	{ after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAssignment__Group_1_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1_1_0_0__0__Impl
+	rule__XAssignment__Group_1_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAssignment__Group_1_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__Group_1_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); }
+	(rule__XAssignment__FeatureAssignment_1_1_0_0_1)
+	{ after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpMultiAssign__Group_5__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpMultiAssign__Group_5__0__Impl
+	rule__OpMultiAssign__Group_5__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); }
+	'<'
+	{ after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpMultiAssign__Group_5__1__Impl
+	rule__OpMultiAssign__Group_5__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); }
+	'<'
+	{ after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpMultiAssign__Group_5__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_5__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); }
+	'='
+	{ after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpMultiAssign__Group_6__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpMultiAssign__Group_6__0__Impl
+	rule__OpMultiAssign__Group_6__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); }
+	'>'
+	{ after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpMultiAssign__Group_6__1__Impl
+	rule__OpMultiAssign__Group_6__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); }
+	('>')?
+	{ after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpMultiAssign__Group_6__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpMultiAssign__Group_6__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); }
+	'>='
+	{ after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group__0__Impl
+	rule__XOrExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); }
+	ruleXAndExpression
+	{ after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getGroup_1()); }
+	(rule__XOrExpression__Group_1__0)*
+	{ after(grammarAccess.getXOrExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group_1__0__Impl
+	rule__XOrExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); }
+	(rule__XOrExpression__Group_1_0__0)
+	{ after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); }
+	(rule__XOrExpression__RightOperandAssignment_1_1)
+	{ after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); }
+	(rule__XOrExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOrExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group_1_0_0__0__Impl
+	rule__XOrExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOrExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+	(rule__XOrExpression__FeatureAssignment_1_0_0_1)
+	{ after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group__0__Impl
+	rule__XAndExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); }
+	ruleXEqualityExpression
+	{ after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getGroup_1()); }
+	(rule__XAndExpression__Group_1__0)*
+	{ after(grammarAccess.getXAndExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group_1__0__Impl
+	rule__XAndExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); }
+	(rule__XAndExpression__Group_1_0__0)
+	{ after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); }
+	(rule__XAndExpression__RightOperandAssignment_1_1)
+	{ after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); }
+	(rule__XAndExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAndExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group_1_0_0__0__Impl
+	rule__XAndExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAndExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+	(rule__XAndExpression__FeatureAssignment_1_0_0_1)
+	{ after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group__0__Impl
+	rule__XEqualityExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); }
+	ruleXRelationalExpression
+	{ after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); }
+	(rule__XEqualityExpression__Group_1__0)*
+	{ after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group_1__0__Impl
+	rule__XEqualityExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); }
+	(rule__XEqualityExpression__Group_1_0__0)
+	{ after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); }
+	(rule__XEqualityExpression__RightOperandAssignment_1_1)
+	{ after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); }
+	(rule__XEqualityExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XEqualityExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group_1_0_0__0__Impl
+	rule__XEqualityExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XEqualityExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+	(rule__XEqualityExpression__FeatureAssignment_1_0_0_1)
+	{ after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group__0__Impl
+	rule__XRelationalExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); }
+	ruleXOtherOperatorExpression
+	{ after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); }
+	(rule__XRelationalExpression__Alternatives_1)*
+	{ after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_0__0__Impl
+	rule__XRelationalExpression__Group_1_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); }
+	(rule__XRelationalExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); }
+	(rule__XRelationalExpression__TypeAssignment_1_0_1)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_0_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); }
+	(rule__XRelationalExpression__Group_1_0_0_0__0)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_0_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_0_0_0__0__Impl
+	rule__XRelationalExpression__Group_1_0_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); }
+	()
+	{ after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_0_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_0_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); }
+	'instanceof'
+	{ after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_1__0__Impl
+	rule__XRelationalExpression__Group_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); }
+	(rule__XRelationalExpression__Group_1_1_0__0)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); }
+	(rule__XRelationalExpression__RightOperandAssignment_1_1_1)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); }
+	(rule__XRelationalExpression__Group_1_1_0_0__0)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XRelationalExpression__Group_1_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_1_0_0__0__Impl
+	rule__XRelationalExpression__Group_1_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XRelationalExpression__Group_1_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__Group_1_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); }
+	(rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1)
+	{ after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpCompare__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpCompare__Group_1__0__Impl
+	rule__OpCompare__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); }
+	'<'
+	{ after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpCompare__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpCompare__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); }
+	'='
+	{ after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group__0__Impl
+	rule__XOtherOperatorExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); }
+	ruleXAdditiveExpression
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); }
+	(rule__XOtherOperatorExpression__Group_1__0)*
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group_1__0__Impl
+	rule__XOtherOperatorExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); }
+	(rule__XOtherOperatorExpression__Group_1_0__0)
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); }
+	(rule__XOtherOperatorExpression__RightOperandAssignment_1_1)
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); }
+	(rule__XOtherOperatorExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XOtherOperatorExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group_1_0_0__0__Impl
+	rule__XOtherOperatorExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XOtherOperatorExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+	(rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1)
+	{ after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_2__0__Impl
+	rule__OpOther__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); }
+	'>'
+	{ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); }
+	'..'
+	{ after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_5__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_5__0__Impl
+	rule__OpOther__Group_5__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); }
+	'>'
+	{ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_5__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); }
+	(rule__OpOther__Alternatives_5_1)
+	{ after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_5_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_5_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); }
+	(rule__OpOther__Group_5_1_0_0__0)
+	{ after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_5_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_5_1_0_0__0__Impl
+	rule__OpOther__Group_5_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); }
+	'>'
+	{ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_5_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_5_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); }
+	'>'
+	{ after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_6__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_6__0__Impl
+	rule__OpOther__Group_6__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); }
+	'<'
+	{ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_6__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); }
+	(rule__OpOther__Alternatives_6_1)
+	{ after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_6_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_6_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); }
+	(rule__OpOther__Group_6_1_0_0__0)
+	{ after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__OpOther__Group_6_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_6_1_0_0__0__Impl
+	rule__OpOther__Group_6_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); }
+	'<'
+	{ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__OpOther__Group_6_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__OpOther__Group_6_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); }
+	'<'
+	{ after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group__0__Impl
+	rule__XAdditiveExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); }
+	ruleXMultiplicativeExpression
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); }
+	(rule__XAdditiveExpression__Group_1__0)*
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group_1__0__Impl
+	rule__XAdditiveExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); }
+	(rule__XAdditiveExpression__Group_1_0__0)
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); }
+	(rule__XAdditiveExpression__RightOperandAssignment_1_1)
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); }
+	(rule__XAdditiveExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XAdditiveExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group_1_0_0__0__Impl
+	rule__XAdditiveExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XAdditiveExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+	(rule__XAdditiveExpression__FeatureAssignment_1_0_0_1)
+	{ after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group__0__Impl
+	rule__XMultiplicativeExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); }
+	ruleXUnaryOperation
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); }
+	(rule__XMultiplicativeExpression__Group_1__0)*
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group_1__0__Impl
+	rule__XMultiplicativeExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); }
+	(rule__XMultiplicativeExpression__Group_1_0__0)
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); }
+	(rule__XMultiplicativeExpression__RightOperandAssignment_1_1)
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); }
+	(rule__XMultiplicativeExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMultiplicativeExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group_1_0_0__0__Impl
+	rule__XMultiplicativeExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMultiplicativeExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+	(rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1)
+	{ after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XUnaryOperation__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XUnaryOperation__Group_0__0__Impl
+	rule__XUnaryOperation__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); }
+	()
+	{ after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XUnaryOperation__Group_0__1__Impl
+	rule__XUnaryOperation__Group_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); }
+	(rule__XUnaryOperation__FeatureAssignment_0_1)
+	{ after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XUnaryOperation__Group_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__Group_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); }
+	(rule__XUnaryOperation__OperandAssignment_0_2)
+	{ after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group__0__Impl
+	rule__XCastedExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); }
+	ruleXPostfixOperation
+	{ after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); }
+	(rule__XCastedExpression__Group_1__0)*
+	{ after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group_1__0__Impl
+	rule__XCastedExpression__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); }
+	(rule__XCastedExpression__Group_1_0__0)
+	{ after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); }
+	(rule__XCastedExpression__TypeAssignment_1_1)
+	{ after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); }
+	(rule__XCastedExpression__Group_1_0_0__0)
+	{ after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCastedExpression__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group_1_0_0__0__Impl
+	rule__XCastedExpression__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCastedExpression__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); }
+	'as'
+	{ after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XPostfixOperation__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XPostfixOperation__Group__0__Impl
+	rule__XPostfixOperation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); }
+	ruleXMemberFeatureCall
+	{ after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XPostfixOperation__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); }
+	(rule__XPostfixOperation__Group_1__0)?
+	{ after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XPostfixOperation__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XPostfixOperation__Group_1__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); }
+	(rule__XPostfixOperation__Group_1_0__0)
+	{ after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XPostfixOperation__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XPostfixOperation__Group_1_0__0__Impl
+	rule__XPostfixOperation__Group_1_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); }
+	()
+	{ after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XPostfixOperation__Group_1_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__Group_1_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); }
+	(rule__XPostfixOperation__FeatureAssignment_1_0_1)
+	{ after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group__0__Impl
+	rule__XMemberFeatureCall__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); }
+	ruleXPrimaryExpression
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); }
+	(rule__XMemberFeatureCall__Alternatives_1)*
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0__0__Impl
+	rule__XMemberFeatureCall__Group_1_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); }
+	(rule__XMemberFeatureCall__Group_1_0_0__0)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); }
+	(rule__XMemberFeatureCall__ValueAssignment_1_0_1)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); }
+	(rule__XMemberFeatureCall__Group_1_0_0_0__0)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_0_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl
+	rule__XMemberFeatureCall__Group_1_0_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); }
+	()
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl
+	rule__XMemberFeatureCall__Group_1_0_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); }
+	(rule__XMemberFeatureCall__Alternatives_1_0_0_0_1)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl
+	rule__XMemberFeatureCall__Group_1_0_0_0__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); }
+	(rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); }
+	ruleOpSingleAssign
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1__0__Impl
+	rule__XMemberFeatureCall__Group_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); }
+	(rule__XMemberFeatureCall__Group_1_1_0__0)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1__1__Impl
+	rule__XMemberFeatureCall__Group_1_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); }
+	(rule__XMemberFeatureCall__Group_1_1_1__0)?
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1__2__Impl
+	rule__XMemberFeatureCall__Group_1_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); }
+	(rule__XMemberFeatureCall__FeatureAssignment_1_1_2)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1__3__Impl
+	rule__XMemberFeatureCall__Group_1_1__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); }
+	(rule__XMemberFeatureCall__Group_1_1_3__0)?
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); }
+	(rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4)?
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); }
+	(rule__XMemberFeatureCall__Group_1_1_0_0__0)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl
+	rule__XMemberFeatureCall__Group_1_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); }
+	()
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); }
+	(rule__XMemberFeatureCall__Alternatives_1_1_0_0_1)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_1__0__Impl
+	rule__XMemberFeatureCall__Group_1_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); }
+	'<'
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_1__1__Impl
+	rule__XMemberFeatureCall__Group_1_1_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); }
+	(rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_1__2__Impl
+	rule__XMemberFeatureCall__Group_1_1_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); }
+	(rule__XMemberFeatureCall__Group_1_1_1_2__0)*
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_1__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); }
+	'>'
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_1_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl
+	rule__XMemberFeatureCall__Group_1_1_1_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); }
+	','
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); }
+	(rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3__0__Impl
+	rule__XMemberFeatureCall__Group_1_1_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); }
+	(rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3__1__Impl
+	rule__XMemberFeatureCall__Group_1_1_3__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); }
+	(rule__XMemberFeatureCall__Alternatives_1_1_3_1)?
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); }
+	')'
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl
+	rule__XMemberFeatureCall__Group_1_1_3_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); }
+	(rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); }
+	(rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0)*
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl
+	rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); }
+	','
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); }
+	(rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1)
+	{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSetLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group__0__Impl
+	rule__XSetLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group__1__Impl
+	rule__XSetLiteral__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); }
+	'#'
+	{ after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group__2__Impl
+	rule__XSetLiteral__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); }
+	'{'
+	{ after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group__3__Impl
+	rule__XSetLiteral__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getGroup_3()); }
+	(rule__XSetLiteral__Group_3__0)?
+	{ after(grammarAccess.getXSetLiteralAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); }
+	'}'
+	{ after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSetLiteral__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group_3__0__Impl
+	rule__XSetLiteral__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); }
+	(rule__XSetLiteral__ElementsAssignment_3_0)
+	{ after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); }
+	(rule__XSetLiteral__Group_3_1__0)*
+	{ after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSetLiteral__Group_3_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group_3_1__0__Impl
+	rule__XSetLiteral__Group_3_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); }
+	','
+	{ after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSetLiteral__Group_3_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__Group_3_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); }
+	(rule__XSetLiteral__ElementsAssignment_3_1_1)
+	{ after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XListLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group__0__Impl
+	rule__XListLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group__1__Impl
+	rule__XListLiteral__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); }
+	'#'
+	{ after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group__2__Impl
+	rule__XListLiteral__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); }
+	'['
+	{ after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group__3__Impl
+	rule__XListLiteral__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getGroup_3()); }
+	(rule__XListLiteral__Group_3__0)?
+	{ after(grammarAccess.getXListLiteralAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); }
+	']'
+	{ after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XListLiteral__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group_3__0__Impl
+	rule__XListLiteral__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); }
+	(rule__XListLiteral__ElementsAssignment_3_0)
+	{ after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); }
+	(rule__XListLiteral__Group_3_1__0)*
+	{ after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XListLiteral__Group_3_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group_3_1__0__Impl
+	rule__XListLiteral__Group_3_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); }
+	','
+	{ after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XListLiteral__Group_3_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__Group_3_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); }
+	(rule__XListLiteral__ElementsAssignment_3_1_1)
+	{ after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group__0__Impl
+	rule__XClosure__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getGroup_0()); }
+	(rule__XClosure__Group_0__0)
+	{ after(grammarAccess.getXClosureAccess().getGroup_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group__1__Impl
+	rule__XClosure__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getGroup_1()); }
+	(rule__XClosure__Group_1__0)?
+	{ after(grammarAccess.getXClosureAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group__2__Impl
+	rule__XClosure__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); }
+	(rule__XClosure__ExpressionAssignment_2)
+	{ after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); }
+	']'
+	{ after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getGroup_0_0()); }
+	(rule__XClosure__Group_0_0__0)
+	{ after(grammarAccess.getXClosureAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_0_0__0__Impl
+	rule__XClosure__Group_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); }
+	()
+	{ after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); }
+	'['
+	{ after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getGroup_1_0()); }
+	(rule__XClosure__Group_1_0__0)
+	{ after(grammarAccess.getXClosureAccess().getGroup_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1_0__0__Impl
+	rule__XClosure__Group_1_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); }
+	(rule__XClosure__Group_1_0_0__0)?
+	{ after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); }
+	(rule__XClosure__ExplicitSyntaxAssignment_1_0_1)
+	{ after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1_0_0__0__Impl
+	rule__XClosure__Group_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); }
+	(rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0)
+	{ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); }
+	(rule__XClosure__Group_1_0_0_1__0)*
+	{ after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XClosure__Group_1_0_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1_0_0_1__0__Impl
+	rule__XClosure__Group_1_0_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); }
+	','
+	{ after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XClosure__Group_1_0_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__Group_1_0_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); }
+	(rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1)
+	{ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XExpressionInClosure__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XExpressionInClosure__Group__0__Impl
+	rule__XExpressionInClosure__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XExpressionInClosure__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); }
+	(rule__XExpressionInClosure__Group_1__0)*
+	{ after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XExpressionInClosure__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XExpressionInClosure__Group_1__0__Impl
+	rule__XExpressionInClosure__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); }
+	(rule__XExpressionInClosure__ExpressionsAssignment_1_0)
+	{ after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XExpressionInClosure__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); }
+	(';')?
+	{ after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group__0__Impl
+	rule__XShortClosure__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getGroup_0()); }
+	(rule__XShortClosure__Group_0__0)
+	{ after(grammarAccess.getXShortClosureAccess().getGroup_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); }
+	(rule__XShortClosure__ExpressionAssignment_1)
+	{ after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); }
+	(rule__XShortClosure__Group_0_0__0)
+	{ after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0__0__Impl
+	rule__XShortClosure__Group_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); }
+	()
+	{ after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0__1__Impl
+	rule__XShortClosure__Group_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); }
+	(rule__XShortClosure__Group_0_0_1__0)?
+	{ after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); }
+	(rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2)
+	{ after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0_1__0__Impl
+	rule__XShortClosure__Group_0_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); }
+	(rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0)
+	{ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); }
+	(rule__XShortClosure__Group_0_0_1_1__0)*
+	{ after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XShortClosure__Group_0_0_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0_1_1__0__Impl
+	rule__XShortClosure__Group_0_0_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); }
+	','
+	{ after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XShortClosure__Group_0_0_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__Group_0_0_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); }
+	(rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1)
+	{ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XParenthesizedExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XParenthesizedExpression__Group__0__Impl
+	rule__XParenthesizedExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+	'('
+	{ after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XParenthesizedExpression__Group__1__Impl
+	rule__XParenthesizedExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); }
+	ruleXExpression
+	{ after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XParenthesizedExpression__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XParenthesizedExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+	')'
+	{ after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XIfExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__0__Impl
+	rule__XIfExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__1__Impl
+	rule__XIfExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); }
+	'if'
+	{ after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__2__Impl
+	rule__XIfExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); }
+	'('
+	{ after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__3__Impl
+	rule__XIfExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); }
+	(rule__XIfExpression__IfAssignment_3)
+	{ after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__4__Impl
+	rule__XIfExpression__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); }
+	')'
+	{ after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__5__Impl
+	rule__XIfExpression__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); }
+	(rule__XIfExpression__ThenAssignment_5)
+	{ after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__6
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group__6__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getGroup_6()); }
+	(rule__XIfExpression__Group_6__0)?
+	{ after(grammarAccess.getXIfExpressionAccess().getGroup_6()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XIfExpression__Group_6__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group_6__0__Impl
+	rule__XIfExpression__Group_6__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group_6__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); }
+	('else')
+	{ after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group_6__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XIfExpression__Group_6__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__Group_6__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); }
+	(rule__XIfExpression__ElseAssignment_6_1)
+	{ after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__0__Impl
+	rule__XSwitchExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__1__Impl
+	rule__XSwitchExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); }
+	'switch'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__2__Impl
+	rule__XSwitchExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); }
+	(rule__XSwitchExpression__Alternatives_2)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__3__Impl
+	rule__XSwitchExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); }
+	'{'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__4__Impl
+	rule__XSwitchExpression__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); }
+	(rule__XSwitchExpression__CasesAssignment_4)*
+	{ after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__5__Impl
+	rule__XSwitchExpression__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); }
+	(rule__XSwitchExpression__Group_5__0)?
+	{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__6
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group__6__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); }
+	'}'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0__0__Impl
+	rule__XSwitchExpression__Group_2_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); }
+	(rule__XSwitchExpression__Group_2_0_0__0)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0__1__Impl
+	rule__XSwitchExpression__Group_2_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); }
+	(rule__XSwitchExpression__SwitchAssignment_2_0_1)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); }
+	')'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); }
+	(rule__XSwitchExpression__Group_2_0_0_0__0)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_0_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0_0_0__0__Impl
+	rule__XSwitchExpression__Group_2_0_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); }
+	'('
+	{ after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0_0_0__1__Impl
+	rule__XSwitchExpression__Group_2_0_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); }
+	(rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_0_0_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_0_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); }
+	':'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_1__0__Impl
+	rule__XSwitchExpression__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); }
+	(rule__XSwitchExpression__Group_2_1_0__0)?
+	{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); }
+	(rule__XSwitchExpression__SwitchAssignment_2_1_1)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_1_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); }
+	(rule__XSwitchExpression__Group_2_1_0_0__0)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_2_1_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_1_0_0__0__Impl
+	rule__XSwitchExpression__Group_2_1_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); }
+	(rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_2_1_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_2_1_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); }
+	':'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSwitchExpression__Group_5__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_5__0__Impl
+	rule__XSwitchExpression__Group_5__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); }
+	'default'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_5__1__Impl
+	rule__XSwitchExpression__Group_5__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); }
+	':'
+	{ after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSwitchExpression__Group_5__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__Group_5__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); }
+	(rule__XSwitchExpression__DefaultAssignment_5_2)
+	{ after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCasePart__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group__0__Impl
+	rule__XCasePart__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); }
+	()
+	{ after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group__1__Impl
+	rule__XCasePart__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); }
+	(rule__XCasePart__TypeGuardAssignment_1)?
+	{ after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group__2__Impl
+	rule__XCasePart__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getGroup_2()); }
+	(rule__XCasePart__Group_2__0)?
+	{ after(grammarAccess.getXCasePartAccess().getGroup_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getAlternatives_3()); }
+	(rule__XCasePart__Alternatives_3)
+	{ after(grammarAccess.getXCasePartAccess().getAlternatives_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCasePart__Group_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group_2__0__Impl
+	rule__XCasePart__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); }
+	'case'
+	{ after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); }
+	(rule__XCasePart__CaseAssignment_2_1)
+	{ after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCasePart__Group_3_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group_3_0__0__Impl
+	rule__XCasePart__Group_3_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_3_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); }
+	':'
+	{ after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_3_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCasePart__Group_3_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__Group_3_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); }
+	(rule__XCasePart__ThenAssignment_3_0_1)
+	{ after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XForLoopExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group__0__Impl
+	rule__XForLoopExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); }
+	(rule__XForLoopExpression__Group_0__0)
+	{ after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group__1__Impl
+	rule__XForLoopExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); }
+	(rule__XForLoopExpression__ForExpressionAssignment_1)
+	{ after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group__2__Impl
+	rule__XForLoopExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); }
+	')'
+	{ after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); }
+	(rule__XForLoopExpression__EachExpressionAssignment_3)
+	{ after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XForLoopExpression__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); }
+	(rule__XForLoopExpression__Group_0_0__0)
+	{ after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XForLoopExpression__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group_0_0__0__Impl
+	rule__XForLoopExpression__Group_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); }
+	()
+	{ after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group_0_0__1__Impl
+	rule__XForLoopExpression__Group_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); }
+	'for'
+	{ after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group_0_0__2__Impl
+	rule__XForLoopExpression__Group_0_0__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+	'('
+	{ after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group_0_0__3__Impl
+	rule__XForLoopExpression__Group_0_0__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); }
+	(rule__XForLoopExpression__DeclaredParamAssignment_0_0_3)
+	{ after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XForLoopExpression__Group_0_0__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__Group_0_0__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); }
+	':'
+	{ after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__0__Impl
+	rule__XBasicForLoopExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__1__Impl
+	rule__XBasicForLoopExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); }
+	'for'
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__2__Impl
+	rule__XBasicForLoopExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); }
+	'('
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__3__Impl
+	rule__XBasicForLoopExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); }
+	(rule__XBasicForLoopExpression__Group_3__0)?
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__4__Impl
+	rule__XBasicForLoopExpression__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); }
+	';'
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__5__Impl
+	rule__XBasicForLoopExpression__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); }
+	(rule__XBasicForLoopExpression__ExpressionAssignment_5)?
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__6
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__6__Impl
+	rule__XBasicForLoopExpression__Group__7
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__6__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); }
+	';'
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__7
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__7__Impl
+	rule__XBasicForLoopExpression__Group__8
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__7__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); }
+	(rule__XBasicForLoopExpression__Group_7__0)?
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__8
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__8__Impl
+	rule__XBasicForLoopExpression__Group__9
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__8__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); }
+	')'
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__9
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group__9__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group__9__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); }
+	(rule__XBasicForLoopExpression__EachExpressionAssignment_9)
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_3__0__Impl
+	rule__XBasicForLoopExpression__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); }
+	(rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0)
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); }
+	(rule__XBasicForLoopExpression__Group_3_1__0)*
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_3_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_3_1__0__Impl
+	rule__XBasicForLoopExpression__Group_3_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); }
+	','
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_3_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_3_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); }
+	(rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1)
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_7__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_7__0__Impl
+	rule__XBasicForLoopExpression__Group_7__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); }
+	(rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0)
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_7__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); }
+	(rule__XBasicForLoopExpression__Group_7_1__0)*
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBasicForLoopExpression__Group_7_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_7_1__0__Impl
+	rule__XBasicForLoopExpression__Group_7_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); }
+	','
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBasicForLoopExpression__Group_7_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__Group_7_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); }
+	(rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1)
+	{ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XWhileExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XWhileExpression__Group__0__Impl
+	rule__XWhileExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XWhileExpression__Group__1__Impl
+	rule__XWhileExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); }
+	'while'
+	{ after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XWhileExpression__Group__2__Impl
+	rule__XWhileExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); }
+	'('
+	{ after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XWhileExpression__Group__3__Impl
+	rule__XWhileExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); }
+	(rule__XWhileExpression__PredicateAssignment_3)
+	{ after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XWhileExpression__Group__4__Impl
+	rule__XWhileExpression__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); }
+	')'
+	{ after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XWhileExpression__Group__5__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); }
+	(rule__XWhileExpression__BodyAssignment_5)
+	{ after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XDoWhileExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__0__Impl
+	rule__XDoWhileExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__1__Impl
+	rule__XDoWhileExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); }
+	'do'
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__2__Impl
+	rule__XDoWhileExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); }
+	(rule__XDoWhileExpression__BodyAssignment_2)
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__3__Impl
+	rule__XDoWhileExpression__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); }
+	'while'
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__4__Impl
+	rule__XDoWhileExpression__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); }
+	'('
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__5__Impl
+	rule__XDoWhileExpression__Group__6
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); }
+	(rule__XDoWhileExpression__PredicateAssignment_5)
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__6
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XDoWhileExpression__Group__6__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__Group__6__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); }
+	')'
+	{ after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBlockExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBlockExpression__Group__0__Impl
+	rule__XBlockExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBlockExpression__Group__1__Impl
+	rule__XBlockExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); }
+	'{'
+	{ after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBlockExpression__Group__2__Impl
+	rule__XBlockExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); }
+	(rule__XBlockExpression__Group_2__0)*
+	{ after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBlockExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); }
+	'}'
+	{ after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBlockExpression__Group_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBlockExpression__Group_2__0__Impl
+	rule__XBlockExpression__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); }
+	(rule__XBlockExpression__ExpressionsAssignment_2_0)
+	{ after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBlockExpression__Group_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__Group_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); }
+	(';')?
+	{ after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group__0__Impl
+	rule__XVariableDeclaration__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); }
+	()
+	{ after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group__1__Impl
+	rule__XVariableDeclaration__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); }
+	(rule__XVariableDeclaration__Alternatives_1)
+	{ after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group__2__Impl
+	rule__XVariableDeclaration__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); }
+	(rule__XVariableDeclaration__Alternatives_2)
+	{ after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); }
+	(rule__XVariableDeclaration__Group_3__0)?
+	{ after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group_2_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group_2_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); }
+	(rule__XVariableDeclaration__Group_2_0_0__0)
+	{ after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group_2_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group_2_0_0__0__Impl
+	rule__XVariableDeclaration__Group_2_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); }
+	(rule__XVariableDeclaration__TypeAssignment_2_0_0_0)
+	{ after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group_2_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_2_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); }
+	(rule__XVariableDeclaration__NameAssignment_2_0_0_1)
+	{ after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XVariableDeclaration__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group_3__0__Impl
+	rule__XVariableDeclaration__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); }
+	'='
+	{ after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XVariableDeclaration__Group_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); }
+	(rule__XVariableDeclaration__RightAssignment_3_1)
+	{ after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmFormalParameter__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmFormalParameter__Group__0__Impl
+	rule__JvmFormalParameter__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+	(rule__JvmFormalParameter__ParameterTypeAssignment_0)?
+	{ after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmFormalParameter__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); }
+	(rule__JvmFormalParameter__NameAssignment_1)
+	{ after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__FullJvmFormalParameter__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__FullJvmFormalParameter__Group__0__Impl
+	rule__FullJvmFormalParameter__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+	(rule__FullJvmFormalParameter__ParameterTypeAssignment_0)
+	{ after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__FullJvmFormalParameter__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); }
+	(rule__FullJvmFormalParameter__NameAssignment_1)
+	{ after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group__0__Impl
+	rule__XFeatureCall__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); }
+	()
+	{ after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group__1__Impl
+	rule__XFeatureCall__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getGroup_1()); }
+	(rule__XFeatureCall__Group_1__0)?
+	{ after(grammarAccess.getXFeatureCallAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group__2__Impl
+	rule__XFeatureCall__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); }
+	(rule__XFeatureCall__FeatureAssignment_2)
+	{ after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group__3__Impl
+	rule__XFeatureCall__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getGroup_3()); }
+	(rule__XFeatureCall__Group_3__0)?
+	{ after(grammarAccess.getXFeatureCallAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); }
+	(rule__XFeatureCall__FeatureCallArgumentsAssignment_4)?
+	{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_1__0__Impl
+	rule__XFeatureCall__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); }
+	'<'
+	{ after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_1__1__Impl
+	rule__XFeatureCall__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); }
+	(rule__XFeatureCall__TypeArgumentsAssignment_1_1)
+	{ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_1__2__Impl
+	rule__XFeatureCall__Group_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); }
+	(rule__XFeatureCall__Group_1_2__0)*
+	{ after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_1__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); }
+	'>'
+	{ after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_1_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_1_2__0__Impl
+	rule__XFeatureCall__Group_1_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); }
+	','
+	{ after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_1_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_1_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); }
+	(rule__XFeatureCall__TypeArgumentsAssignment_1_2_1)
+	{ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3__0__Impl
+	rule__XFeatureCall__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); }
+	(rule__XFeatureCall__ExplicitOperationCallAssignment_3_0)
+	{ after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3__1__Impl
+	rule__XFeatureCall__Group_3__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); }
+	(rule__XFeatureCall__Alternatives_3_1)?
+	{ after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); }
+	')'
+	{ after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_3_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3_1_1__0__Impl
+	rule__XFeatureCall__Group_3_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); }
+	(rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0)
+	{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); }
+	(rule__XFeatureCall__Group_3_1_1_1__0)*
+	{ after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFeatureCall__Group_3_1_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3_1_1_1__0__Impl
+	rule__XFeatureCall__Group_3_1_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); }
+	','
+	{ after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFeatureCall__Group_3_1_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__Group_3_1_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); }
+	(rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1)
+	{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group__0__Impl
+	rule__XConstructorCall__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); }
+	()
+	{ after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group__1__Impl
+	rule__XConstructorCall__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); }
+	'new'
+	{ after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group__2__Impl
+	rule__XConstructorCall__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); }
+	(rule__XConstructorCall__ConstructorAssignment_2)
+	{ after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group__3__Impl
+	rule__XConstructorCall__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getGroup_3()); }
+	(rule__XConstructorCall__Group_3__0)?
+	{ after(grammarAccess.getXConstructorCallAccess().getGroup_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group__4__Impl
+	rule__XConstructorCall__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getGroup_4()); }
+	(rule__XConstructorCall__Group_4__0)?
+	{ after(grammarAccess.getXConstructorCallAccess().getGroup_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group__5__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); }
+	(rule__XConstructorCall__ArgumentsAssignment_5)?
+	{ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_3__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_3__0__Impl
+	rule__XConstructorCall__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); }
+	('<')
+	{ after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_3__1__Impl
+	rule__XConstructorCall__Group_3__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); }
+	(rule__XConstructorCall__TypeArgumentsAssignment_3_1)
+	{ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_3__2__Impl
+	rule__XConstructorCall__Group_3__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); }
+	(rule__XConstructorCall__Group_3_2__0)*
+	{ after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_3__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); }
+	'>'
+	{ after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_3_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_3_2__0__Impl
+	rule__XConstructorCall__Group_3_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); }
+	','
+	{ after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_3_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_3_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); }
+	(rule__XConstructorCall__TypeArgumentsAssignment_3_2_1)
+	{ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_4__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4__0__Impl
+	rule__XConstructorCall__Group_4__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); }
+	(rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0)
+	{ after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4__1__Impl
+	rule__XConstructorCall__Group_4__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); }
+	(rule__XConstructorCall__Alternatives_4_1)?
+	{ after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); }
+	')'
+	{ after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_4_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4_1_1__0__Impl
+	rule__XConstructorCall__Group_4_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); }
+	(rule__XConstructorCall__ArgumentsAssignment_4_1_1_0)
+	{ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); }
+	(rule__XConstructorCall__Group_4_1_1_1__0)*
+	{ after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XConstructorCall__Group_4_1_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4_1_1_1__0__Impl
+	rule__XConstructorCall__Group_4_1_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); }
+	','
+	{ after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XConstructorCall__Group_4_1_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__Group_4_1_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); }
+	(rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1)
+	{ after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XBooleanLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBooleanLiteral__Group__0__Impl
+	rule__XBooleanLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XBooleanLiteral__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); }
+	(rule__XBooleanLiteral__Alternatives_1)
+	{ after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XNullLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XNullLiteral__Group__0__Impl
+	rule__XNullLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNullLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNullLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XNullLiteral__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNullLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); }
+	'null'
+	{ after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XNumberLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XNumberLiteral__Group__0__Impl
+	rule__XNumberLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XNumberLiteral__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); }
+	(rule__XNumberLiteral__ValueAssignment_1)
+	{ after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XStringLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XStringLiteral__Group__0__Impl
+	rule__XStringLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XStringLiteral__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); }
+	(rule__XStringLiteral__ValueAssignment_1)
+	{ after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XTypeLiteral__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTypeLiteral__Group__0__Impl
+	rule__XTypeLiteral__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); }
+	()
+	{ after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTypeLiteral__Group__1__Impl
+	rule__XTypeLiteral__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); }
+	'typeof'
+	{ after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTypeLiteral__Group__2__Impl
+	rule__XTypeLiteral__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); }
+	'('
+	{ after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTypeLiteral__Group__3__Impl
+	rule__XTypeLiteral__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); }
+	(rule__XTypeLiteral__TypeAssignment_3)
+	{ after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTypeLiteral__Group__4__Impl
+	rule__XTypeLiteral__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); }
+	(rule__XTypeLiteral__ArrayDimensionsAssignment_4)*
+	{ after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTypeLiteral__Group__5__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__Group__5__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); }
+	')'
+	{ after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XThrowExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XThrowExpression__Group__0__Impl
+	rule__XThrowExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XThrowExpression__Group__1__Impl
+	rule__XThrowExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); }
+	'throw'
+	{ after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XThrowExpression__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); }
+	(rule__XThrowExpression__ExpressionAssignment_2)
+	{ after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XReturnExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XReturnExpression__Group__0__Impl
+	rule__XReturnExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XReturnExpression__Group__1__Impl
+	rule__XReturnExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); }
+	'return'
+	{ after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XReturnExpression__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); }
+	(rule__XReturnExpression__ExpressionAssignment_2)?
+	{ after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group__0__Impl
+	rule__XTryCatchFinallyExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); }
+	()
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group__1__Impl
+	rule__XTryCatchFinallyExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); }
+	'try'
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group__2__Impl
+	rule__XTryCatchFinallyExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); }
+	(rule__XTryCatchFinallyExpression__ExpressionAssignment_2)
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); }
+	(rule__XTryCatchFinallyExpression__Alternatives_3)
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group_3_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group_3_0__0__Impl
+	rule__XTryCatchFinallyExpression__Group_3_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+		(rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+	)
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+		(rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0)*
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); }
+	)
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group_3_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); }
+	(rule__XTryCatchFinallyExpression__Group_3_0_1__0)?
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl
+	rule__XTryCatchFinallyExpression__Group_3_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); }
+	('finally')
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); }
+	(rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1)
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XTryCatchFinallyExpression__Group_3_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group_3_1__0__Impl
+	rule__XTryCatchFinallyExpression__Group_3_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); }
+	'finally'
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XTryCatchFinallyExpression__Group_3_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__Group_3_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); }
+	(rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1)
+	{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSynchronizedExpression__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group__0__Impl
+	rule__XSynchronizedExpression__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); }
+	(rule__XSynchronizedExpression__Group_0__0)
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group__1__Impl
+	rule__XSynchronizedExpression__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); }
+	(rule__XSynchronizedExpression__ParamAssignment_1)
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group__2__Impl
+	rule__XSynchronizedExpression__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); }
+	')'
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); }
+	(rule__XSynchronizedExpression__ExpressionAssignment_3)
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSynchronizedExpression__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); }
+	(rule__XSynchronizedExpression__Group_0_0__0)
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XSynchronizedExpression__Group_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group_0_0__0__Impl
+	rule__XSynchronizedExpression__Group_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); }
+	()
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group_0_0__1__Impl
+	rule__XSynchronizedExpression__Group_0_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); }
+	'synchronized'
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XSynchronizedExpression__Group_0_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__Group_0_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+	'('
+	{ after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XCatchClause__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCatchClause__Group__0__Impl
+	rule__XCatchClause__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); }
+	('catch')
+	{ after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCatchClause__Group__1__Impl
+	rule__XCatchClause__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); }
+	'('
+	{ after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCatchClause__Group__2__Impl
+	rule__XCatchClause__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); }
+	(rule__XCatchClause__DeclaredParamAssignment_2)
+	{ after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCatchClause__Group__3__Impl
+	rule__XCatchClause__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); }
+	')'
+	{ after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XCatchClause__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__Group__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); }
+	(rule__XCatchClause__ExpressionAssignment_4)
+	{ after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedName__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedName__Group__0__Impl
+	rule__QualifiedName__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); }
+	ruleValidID
+	{ after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedName__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
+	(rule__QualifiedName__Group_1__0)*
+	{ after(grammarAccess.getQualifiedNameAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedName__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedName__Group_1__0__Impl
+	rule__QualifiedName__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); }
+	('.')
+	{ after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedName__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedName__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); }
+	ruleValidID
+	{ after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Number__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__Number__Group_1__0__Impl
+	rule__Number__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getNumberAccess().getAlternatives_1_0()); }
+	(rule__Number__Alternatives_1_0)
+	{ after(grammarAccess.getNumberAccess().getAlternatives_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__Number__Group_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getNumberAccess().getGroup_1_1()); }
+	(rule__Number__Group_1_1__0)?
+	{ after(grammarAccess.getNumberAccess().getGroup_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Number__Group_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__Number__Group_1_1__0__Impl
+	rule__Number__Group_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); }
+	'.'
+	{ after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__Number__Group_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Number__Group_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); }
+	(rule__Number__Alternatives_1_1_1)
+	{ after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmTypeReference__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmTypeReference__Group_0__0__Impl
+	rule__JvmTypeReference__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); }
+	ruleJvmParameterizedTypeReference
+	{ after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmTypeReference__Group_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); }
+	(rule__JvmTypeReference__Group_0_1__0)*
+	{ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmTypeReference__Group_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmTypeReference__Group_0_1__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); }
+	(rule__JvmTypeReference__Group_0_1_0__0)
+	{ after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmTypeReference__Group_0_1_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmTypeReference__Group_0_1_0__0__Impl
+	rule__JvmTypeReference__Group_0_1_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); }
+	()
+	{ after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmTypeReference__Group_0_1_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmTypeReference__Group_0_1_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); }
+	ruleArrayBrackets
+	{ after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__ArrayBrackets__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__ArrayBrackets__Group__0__Impl
+	rule__ArrayBrackets__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ArrayBrackets__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); }
+	'['
+	{ after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ArrayBrackets__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__ArrayBrackets__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__ArrayBrackets__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); }
+	']'
+	{ after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group__0__Impl
+	rule__XFunctionTypeRef__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); }
+	(rule__XFunctionTypeRef__Group_0__0)?
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group__1__Impl
+	rule__XFunctionTypeRef__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+	'=>'
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); }
+	(rule__XFunctionTypeRef__ReturnTypeAssignment_2)
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0__0__Impl
+	rule__XFunctionTypeRef__Group_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); }
+	'('
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0__1__Impl
+	rule__XFunctionTypeRef__Group_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); }
+	(rule__XFunctionTypeRef__Group_0_1__0)?
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); }
+	')'
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group_0_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0_1__0__Impl
+	rule__XFunctionTypeRef__Group_0_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); }
+	(rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0)
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); }
+	(rule__XFunctionTypeRef__Group_0_1_1__0)*
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XFunctionTypeRef__Group_0_1_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0_1_1__0__Impl
+	rule__XFunctionTypeRef__Group_0_1_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); }
+	','
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__XFunctionTypeRef__Group_0_1_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__Group_0_1_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); }
+	(rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1)
+	{ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group__0__Impl
+	rule__JvmParameterizedTypeReference__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); }
+	(rule__JvmParameterizedTypeReference__TypeAssignment_0)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); }
+	(rule__JvmParameterizedTypeReference__Group_1__0)?
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1__0__Impl
+	rule__JvmParameterizedTypeReference__Group_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); }
+	('<')
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1__1__Impl
+	rule__JvmParameterizedTypeReference__Group_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); }
+	(rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1__2__Impl
+	rule__JvmParameterizedTypeReference__Group_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); }
+	(rule__JvmParameterizedTypeReference__Group_1_2__0)*
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1__3__Impl
+	rule__JvmParameterizedTypeReference__Group_1__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); }
+	'>'
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1__4__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); }
+	(rule__JvmParameterizedTypeReference__Group_1_4__0)*
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_2__0__Impl
+	rule__JvmParameterizedTypeReference__Group_1_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); }
+	','
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); }
+	(rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4__0__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); }
+	(rule__JvmParameterizedTypeReference__Group_1_4_0__0)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4__1__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); }
+	(rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); }
+	(rule__JvmParameterizedTypeReference__Group_1_4_2__0)?
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); }
+	(rule__JvmParameterizedTypeReference__Group_1_4_0_0__0)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4_0_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); }
+	()
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); }
+	'.'
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); }
+	('<')
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4_2__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); }
+	(rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4_2__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); }
+	(rule__JvmParameterizedTypeReference__Group_1_4_2_2__0)*
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); }
+	'>'
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl
+	rule__JvmParameterizedTypeReference__Group_1_4_2_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); }
+	','
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); }
+	(rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1)
+	{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmWildcardTypeReference__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group__0__Impl
+	rule__JvmWildcardTypeReference__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); }
+	()
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group__1__Impl
+	rule__JvmWildcardTypeReference__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); }
+	'?'
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); }
+	(rule__JvmWildcardTypeReference__Alternatives_2)?
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmWildcardTypeReference__Group_2_0__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group_2_0__0__Impl
+	rule__JvmWildcardTypeReference__Group_2_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_0__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); }
+	(rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0)
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_0__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group_2_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_0__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); }
+	(rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1)*
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmWildcardTypeReference__Group_2_1__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group_2_1__0__Impl
+	rule__JvmWildcardTypeReference__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_1__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); }
+	(rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0)
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_1__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmWildcardTypeReference__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__Group_2_1__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); }
+	(rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1)*
+	{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmUpperBound__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmUpperBound__Group__0__Impl
+	rule__JvmUpperBound__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); }
+	'extends'
+	{ after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmUpperBound__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); }
+	(rule__JvmUpperBound__TypeReferenceAssignment_1)
+	{ after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmUpperBoundAnded__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmUpperBoundAnded__Group__0__Impl
+	rule__JvmUpperBoundAnded__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); }
+	'&'
+	{ after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmUpperBoundAnded__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); }
+	(rule__JvmUpperBoundAnded__TypeReferenceAssignment_1)
+	{ after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmLowerBound__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmLowerBound__Group__0__Impl
+	rule__JvmLowerBound__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); }
+	'super'
+	{ after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmLowerBound__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); }
+	(rule__JvmLowerBound__TypeReferenceAssignment_1)
+	{ after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__JvmLowerBoundAnded__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmLowerBoundAnded__Group__0__Impl
+	rule__JvmLowerBoundAnded__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); }
+	'&'
+	{ after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__JvmLowerBoundAnded__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); }
+	(rule__JvmLowerBoundAnded__TypeReferenceAssignment_1)
+	{ after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameWithWildcard__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedNameWithWildcard__Group__0__Impl
+	rule__QualifiedNameWithWildcard__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); }
+	ruleQualifiedName
+	{ after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedNameWithWildcard__Group__1__Impl
+	rule__QualifiedNameWithWildcard__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); }
+	'.'
+	{ after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedNameWithWildcard__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameWithWildcard__Group__2__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); }
+	'*'
+	{ after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__QualifiedNameInStaticImport__Group__0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedNameInStaticImport__Group__0__Impl
+	rule__QualifiedNameInStaticImport__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameInStaticImport__Group__0__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); }
+	ruleValidID
+	{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameInStaticImport__Group__1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	rule__QualifiedNameInStaticImport__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__QualifiedNameInStaticImport__Group__1__Impl
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+(
+	{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); }
+	'.'
+	{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); }
+)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__XImportDeclaration__StaticAssignment_2_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+		(
+			{ before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+			'static'
+			{ after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+		)
+		{ after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ExtensionAssignment_2_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+		(
+			{ before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+			'extension'
+			{ after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+		)
+		{ after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedTypeAssignment_2_0_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0()); }
+		(
+			{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1()); }
+			ruleQualifiedNameInStaticImport
+			{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1()); }
+		)
+		{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__WildcardAssignment_2_0_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+		(
+			{ before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+			'*'
+			{ after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+		)
+		{ after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__MemberNameAssignment_2_0_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0()); }
+		ruleValidID
+		{ after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedTypeAssignment_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0()); }
+		(
+			{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1()); }
+			ruleQualifiedName
+			{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1()); }
+		)
+		{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedNamespaceAssignment_2_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0()); }
+		ruleQualifiedNameWithWildcard
+		{ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__FqnImportAssignment_2_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+		(
+			{ before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+			'ns'
+			{ after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+		)
+		{ after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0()); }
+		ruleQualifiedName
+		{ after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__AnnotationTypeAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0()); }
+		(
+			{ before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1()); }
+			ruleQualifiedName
+			{ after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1()); }
+		)
+		{ after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0()); }
+		ruleXAnnotationElementValuePair
+		{ after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0()); }
+		ruleXAnnotationElementValuePair
+		{ after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotation__ValueAssignment_3_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0()); }
+		ruleXAnnotationElementValueOrCommaList
+		{ after(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__ElementAssignment_0_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0()); }
+		(
+			{ before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1()); }
+			ruleValidID
+			{ after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1()); }
+		)
+		{ after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValuePair__ValueAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0()); }
+		ruleXAnnotationElementValue
+		{ after(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+		ruleXAnnotationOrExpression
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+		ruleXAnnotationOrExpression
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0()); }
+		ruleXAnnotationOrExpression
+		{ after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__ElementsAssignment_0_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+		ruleXAnnotationOrExpression
+		{ after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+		ruleXAnnotationOrExpression
+		{ after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__FeatureAssignment_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+		(
+			{ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); }
+			ruleFeatureCallID
+			{ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__ValueAssignment_0_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); }
+		ruleXAssignment
+		{ after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__FeatureAssignment_1_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); }
+			ruleOpMultiAssign
+			{ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAssignment__RightOperandAssignment_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); }
+		ruleXAssignment
+		{ after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__FeatureAssignment_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); }
+			ruleOpOr
+			{ after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOrExpression__RightOperandAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); }
+		ruleXAndExpression
+		{ after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__FeatureAssignment_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); }
+			ruleOpAnd
+			{ after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAndExpression__RightOperandAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); }
+		ruleXEqualityExpression
+		{ after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__FeatureAssignment_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); }
+			ruleOpEquality
+			{ after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XEqualityExpression__RightOperandAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); }
+		ruleXRelationalExpression
+		{ after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__TypeAssignment_1_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); }
+			ruleOpCompare
+			{ after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XRelationalExpression__RightOperandAssignment_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); }
+		ruleXOtherOperatorExpression
+		{ after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); }
+			ruleOpOther
+			{ after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XOtherOperatorExpression__RightOperandAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); }
+		ruleXAdditiveExpression
+		{ after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__FeatureAssignment_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); }
+			ruleOpAdd
+			{ after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XAdditiveExpression__RightOperandAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); }
+		ruleXMultiplicativeExpression
+		{ after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+		(
+			{ before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); }
+			ruleOpMulti
+			{ after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMultiplicativeExpression__RightOperandAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); }
+		ruleXUnaryOperation
+		{ after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__FeatureAssignment_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+		(
+			{ before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); }
+			ruleOpUnary
+			{ after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XUnaryOperation__OperandAssignment_0_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); }
+		ruleXUnaryOperation
+		{ after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCastedExpression__TypeAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XPostfixOperation__FeatureAssignment_1_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); }
+		(
+			{ before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); }
+			ruleOpPostfix
+			{ after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); }
+		)
+		{ after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+		(
+			{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+			'::'
+			{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+		)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); }
+		(
+			{ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); }
+			ruleFeatureCallID
+			{ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); }
+		)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ValueAssignment_1_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); }
+		ruleXAssignment
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+		(
+			{ before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+			'?.'
+			{ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+		)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+		(
+			{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+			'::'
+			{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+		)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__FeatureAssignment_1_1_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); }
+		(
+			{ before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); }
+			ruleIdOrSuper
+			{ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); }
+		)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+		(
+			{ before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+			'('
+			{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+		)
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); }
+		ruleXShortClosure
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); }
+		ruleXClosure
+		{ after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__ElementsAssignment_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSetLiteral__ElementsAssignment_3_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__ElementsAssignment_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XListLiteral__ElementsAssignment_3_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__ExplicitSyntaxAssignment_1_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+		(
+			{ before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+			'|'
+			{ after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+		)
+		{ after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XClosure__ExpressionAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); }
+		ruleXExpressionInClosure
+		{ after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XExpressionInClosure__ExpressionsAssignment_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); }
+		ruleXExpressionOrVarDeclaration
+		{ after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+		(
+			{ before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+			'|'
+			{ after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+		)
+		{ after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XShortClosure__ExpressionAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__IfAssignment_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__ThenAssignment_5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XIfExpression__ElseAssignment_6_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__SwitchAssignment_2_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__SwitchAssignment_2_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__CasesAssignment_4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); }
+		ruleXCasePart
+		{ after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSwitchExpression__DefaultAssignment_5_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__TypeGuardAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__CaseAssignment_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__ThenAssignment_3_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCasePart__FallThroughAssignment_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+		(
+			{ before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+			','
+			{ after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+		)
+		{ after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__DeclaredParamAssignment_0_0_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); }
+		ruleJvmFormalParameter
+		{ after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__ForExpressionAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XForLoopExpression__EachExpressionAssignment_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); }
+		ruleXExpressionOrVarDeclaration
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); }
+		ruleXExpressionOrVarDeclaration
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__ExpressionAssignment_5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBasicForLoopExpression__EachExpressionAssignment_9
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__PredicateAssignment_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XWhileExpression__BodyAssignment_5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__BodyAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XDoWhileExpression__PredicateAssignment_5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBlockExpression__ExpressionsAssignment_2_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); }
+		ruleXExpressionOrVarDeclaration
+		{ after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__WriteableAssignment_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+		(
+			{ before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+			'var'
+			{ after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+		)
+		{ after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__TypeAssignment_2_0_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__NameAssignment_2_0_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); }
+		ruleValidID
+		{ after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__NameAssignment_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); }
+		ruleValidID
+		{ after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XVariableDeclaration__RightAssignment_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__ParameterTypeAssignment_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmFormalParameter__NameAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+		ruleValidID
+		{ after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__ParameterTypeAssignment_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__FullJvmFormalParameter__NameAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+		ruleValidID
+		{ after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__TypeArgumentsAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__TypeArgumentsAssignment_1_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); }
+		(
+			{ before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); }
+			ruleIdOrSuper
+			{ after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); }
+		)
+		{ after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__ExplicitOperationCallAssignment_3_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+		(
+			{ before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+			'('
+			{ after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+		)
+		{ after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); }
+		ruleXShortClosure
+		{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFeatureCall__FeatureCallArgumentsAssignment_4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); }
+		ruleXClosure
+		{ after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ConstructorAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); }
+		(
+			{ before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); }
+			ruleQualifiedName
+			{ after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); }
+		)
+		{ after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__TypeArgumentsAssignment_3_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__TypeArgumentsAssignment_3_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+		(
+			{ before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+			'('
+			{ after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+		)
+		{ after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_4_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); }
+		ruleXShortClosure
+		{ after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_4_1_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XConstructorCall__ArgumentsAssignment_5
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); }
+		ruleXClosure
+		{ after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XBooleanLiteral__IsTrueAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+		(
+			{ before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+			'true'
+			{ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+		)
+		{ after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XNumberLiteral__ValueAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); }
+		ruleNumber
+		{ after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XStringLiteral__ValueAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); }
+		RULE_STRING
+		{ after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__TypeAssignment_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); }
+		(
+			{ before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); }
+			ruleQualifiedName
+			{ after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); }
+		)
+		{ after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTypeLiteral__ArrayDimensionsAssignment_4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); }
+		ruleArrayBrackets
+		{ after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XThrowExpression__ExpressionAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XReturnExpression__ExpressionAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__ExpressionAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); }
+		ruleXCatchClause
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__ParamAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XSynchronizedExpression__ExpressionAssignment_3
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__DeclaredParamAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); }
+		ruleFullJvmFormalParameter
+		{ after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XCatchClause__ExpressionAssignment_4
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); }
+		ruleXExpression
+		{ after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XFunctionTypeRef__ReturnTypeAssignment_2
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__TypeAssignment_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); }
+		(
+			{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); }
+			ruleQualifiedName
+			{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); }
+		)
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); }
+		(
+			{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); }
+			ruleValidID
+			{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); }
+		)
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); }
+		ruleJvmArgumentTypeReference
+		{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); }
+		ruleJvmUpperBound
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); }
+		ruleJvmUpperBoundAnded
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); }
+		ruleJvmLowerBound
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); }
+		ruleJvmLowerBoundAnded
+		{ after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBound__TypeReferenceAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmUpperBoundAnded__TypeReferenceAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBound__TypeReferenceAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__JvmLowerBoundAnded__TypeReferenceAssignment_1
+	@init {
+		int stackSize = keepStackSize();
+	}
+:
+	(
+		{ before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+		ruleJvmTypeReference
+		{ after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); }
+	)
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?;
+
+RULE_INT : '0'..'9' ('0'..'9'|'_')*;
+
+RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?;
+
+RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*;
+
+RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?);
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.tokens b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.tokens
new file mode 100644
index 0000000..492b3ba
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtype.tokens
@@ -0,0 +1,161 @@
+'!'=40
+'!='=22
+'!=='=24
+'#'=57
+'%'=39
+'%='=20
+'&&'=15
+'&'=82
+'('=53
+')'=54
+'*'=36
+'**'=37
+'*='=18
+'+'=34
+'++'=41
+'+='=16
+','=55
+'-'=35
+'--'=42
+'-='=17
+'->'=28
+'.'=43
+'..'=30
+'..<'=29
+'/'=38
+'/='=19
+':'=66
+'::'=84
+';'=51
+'<'=27
+'<>'=32
+'='=13
+'=='=21
+'==='=23
+'=>'=31
+'>'=26
+'>='=25
+'?'=81
+'?.'=85
+'?:'=33
+'@'=52
+'['=58
+']'=56
+'as'=60
+'case'=68
+'catch'=80
+'default'=67
+'do'=71
+'else'=64
+'extends'=45
+'extension'=48
+'false'=50
+'finally'=78
+'for'=69
+'if'=63
+'import'=47
+'instanceof'=59
+'new'=72
+'ns'=83
+'null'=73
+'return'=76
+'static'=46
+'super'=49
+'switch'=65
+'synchronized'=79
+'throw'=75
+'true'=88
+'try'=77
+'typeof'=74
+'val'=44
+'var'=87
+'while'=70
+'{'=61
+'|'=86
+'||'=14
+'}'=62
+RULE_ANY_OTHER=12
+RULE_DECIMAL=7
+RULE_HEX=5
+RULE_ID=4
+RULE_INT=6
+RULE_ML_COMMENT=9
+RULE_SL_COMMENT=10
+RULE_STRING=8
+RULE_WS=11
+T__13=13
+T__14=14
+T__15=15
+T__16=16
+T__17=17
+T__18=18
+T__19=19
+T__20=20
+T__21=21
+T__22=22
+T__23=23
+T__24=24
+T__25=25
+T__26=26
+T__27=27
+T__28=28
+T__29=29
+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
+T__40=40
+T__41=41
+T__42=42
+T__43=43
+T__44=44
+T__45=45
+T__46=46
+T__47=47
+T__48=48
+T__49=49
+T__50=50
+T__51=51
+T__52=52
+T__53=53
+T__54=54
+T__55=55
+T__56=56
+T__57=57
+T__58=58
+T__59=59
+T__60=60
+T__61=61
+T__62=62
+T__63=63
+T__64=64
+T__65=65
+T__66=66
+T__67=67
+T__68=68
+T__69=69
+T__70=70
+T__71=71
+T__72=72
+T__73=73
+T__74=74
+T__75=75
+T__76=76
+T__77=77
+T__78=78
+T__79=79
+T__80=80
+T__81=81
+T__82=82
+T__83=83
+T__84=84
+T__85=85
+T__86=86
+T__87=87
+T__88=88
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeLexer.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeLexer.java
new file mode 100644
index 0000000..d490114
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeLexer.java
@@ -0,0 +1,3533 @@
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import. 
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalOXtypeLexer extends Lexer {
+    public static final int RULE_HEX=5;
+    public static final int T__50=50;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__59=59;
+    public static final int T__16=16;
+    public static final int T__17=17;
+    public static final int T__18=18;
+    public static final int T__55=55;
+    public static final int T__56=56;
+    public static final int T__13=13;
+    public static final int T__57=57;
+    public static final int T__14=14;
+    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__60=60;
+    public static final int T__61=61;
+    public static final int RULE_ID=4;
+    public static final int RULE_DECIMAL=7;
+    public static final int T__26=26;
+    public static final int T__27=27;
+    public static final int T__28=28;
+    public static final int RULE_INT=6;
+    public static final int T__29=29;
+    public static final int T__22=22;
+    public static final int T__66=66;
+    public static final int RULE_ML_COMMENT=9;
+    public static final int T__23=23;
+    public static final int T__67=67;
+    public static final int T__24=24;
+    public static final int T__68=68;
+    public static final int T__25=25;
+    public static final int T__69=69;
+    public static final int T__62=62;
+    public static final int T__63=63;
+    public static final int T__20=20;
+    public static final int T__64=64;
+    public static final int T__21=21;
+    public static final int T__65=65;
+    public static final int T__70=70;
+    public static final int T__71=71;
+    public static final int T__72=72;
+    public static final int RULE_STRING=8;
+    public static final int RULE_SL_COMMENT=10;
+    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 T__33=33;
+    public static final int T__77=77;
+    public static final int T__34=34;
+    public static final int T__78=78;
+    public static final int T__35=35;
+    public static final int T__79=79;
+    public static final int T__36=36;
+    public static final int T__73=73;
+    public static final int EOF=-1;
+    public static final int T__30=30;
+    public static final int T__74=74;
+    public static final int T__31=31;
+    public static final int T__75=75;
+    public static final int T__32=32;
+    public static final int T__76=76;
+    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 RULE_WS=11;
+    public static final int RULE_ANY_OTHER=12;
+    public static final int T__48=48;
+    public static final int T__49=49;
+    public static final int T__44=44;
+    public static final int T__88=88;
+    public static final int T__45=45;
+    public static final int T__46=46;
+    public static final int T__47=47;
+    public static final int T__40=40;
+    public static final int T__84=84;
+    public static final int T__41=41;
+    public static final int T__85=85;
+    public static final int T__42=42;
+    public static final int T__86=86;
+    public static final int T__43=43;
+    public static final int T__87=87;
+
+    // delegates
+    // delegators
+
+    public InternalOXtypeLexer() {;} 
+    public InternalOXtypeLexer(CharStream input) {
+        this(input, new RecognizerSharedState());
+    }
+    public InternalOXtypeLexer(CharStream input, RecognizerSharedState state) {
+        super(input,state);
+
+    }
+    public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+    // $ANTLR start "T__13"
+    public final void mT__13() throws RecognitionException {
+        try {
+            int _type = T__13;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:11:7: ( '=' )
+            // InternalOXtype.g:11: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;
+            // InternalOXtype.g:12:7: ( '||' )
+            // InternalOXtype.g:12: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;
+            // InternalOXtype.g:13:7: ( '&&' )
+            // InternalOXtype.g:13: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;
+            // InternalOXtype.g:14:7: ( '+=' )
+            // InternalOXtype.g:14:9: '+='
+            {
+            match("+="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:15:7: ( '-=' )
+            // InternalOXtype.g:15:9: '-='
+            {
+            match("-="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:16:7: ( '*=' )
+            // InternalOXtype.g:16: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;
+            // InternalOXtype.g:17:7: ( '/=' )
+            // InternalOXtype.g:17: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;
+            // InternalOXtype.g:18:7: ( '%=' )
+            // InternalOXtype.g:18: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;
+            // InternalOXtype.g:19:7: ( '==' )
+            // InternalOXtype.g:19: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;
+            // InternalOXtype.g:20:7: ( '!=' )
+            // InternalOXtype.g:20: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;
+            // InternalOXtype.g:21:7: ( '===' )
+            // InternalOXtype.g:21: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;
+            // InternalOXtype.g:22:7: ( '!==' )
+            // InternalOXtype.g:22: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;
+            // InternalOXtype.g:23:7: ( '>=' )
+            // InternalOXtype.g:23: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;
+            // InternalOXtype.g:24:7: ( '>' )
+            // InternalOXtype.g:24: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;
+            // InternalOXtype.g:25:7: ( '<' )
+            // InternalOXtype.g:25: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;
+            // InternalOXtype.g:26:7: ( '->' )
+            // InternalOXtype.g:26: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;
+            // InternalOXtype.g:27:7: ( '..<' )
+            // InternalOXtype.g:27: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;
+            // InternalOXtype.g:28:7: ( '..' )
+            // InternalOXtype.g:28: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;
+            // InternalOXtype.g:29:7: ( '=>' )
+            // InternalOXtype.g:29: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;
+            // InternalOXtype.g:30:7: ( '<>' )
+            // InternalOXtype.g:30: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;
+            // InternalOXtype.g:31:7: ( '?:' )
+            // InternalOXtype.g:31:9: '?:'
+            {
+            match("?:"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:32:7: ( '+' )
+            // InternalOXtype.g:32:9: '+'
+            {
+            match('+'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:33:7: ( '-' )
+            // InternalOXtype.g:33:9: '-'
+            {
+            match('-'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:34:7: ( '*' )
+            // InternalOXtype.g:34:9: '*'
+            {
+            match('*'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:35:7: ( '**' )
+            // InternalOXtype.g:35:9: '**'
+            {
+            match("**"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:36:7: ( '/' )
+            // InternalOXtype.g:36:9: '/'
+            {
+            match('/'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:37:7: ( '%' )
+            // InternalOXtype.g:37:9: '%'
+            {
+            match('%'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:38:7: ( '!' )
+            // InternalOXtype.g:38:9: '!'
+            {
+            match('!'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:39:7: ( '++' )
+            // InternalOXtype.g:39:9: '++'
+            {
+            match("++"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:40:7: ( '--' )
+            // InternalOXtype.g:40:9: '--'
+            {
+            match("--"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:41:7: ( '.' )
+            // InternalOXtype.g:41:9: '.'
+            {
+            match('.'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:42:7: ( 'val' )
+            // InternalOXtype.g:42:9: 'val'
+            {
+            match("val"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:43:7: ( 'extends' )
+            // InternalOXtype.g:43:9: 'extends'
+            {
+            match("extends"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:44:7: ( 'static' )
+            // InternalOXtype.g:44:9: 'static'
+            {
+            match("static"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:45:7: ( 'import' )
+            // InternalOXtype.g:45:9: 'import'
+            {
+            match("import"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:46:7: ( 'extension' )
+            // InternalOXtype.g:46:9: 'extension'
+            {
+            match("extension"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:47:7: ( 'super' )
+            // InternalOXtype.g:47:9: 'super'
+            {
+            match("super"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:48:7: ( 'false' )
+            // InternalOXtype.g:48:9: 'false'
+            {
+            match("false"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:49:7: ( ';' )
+            // InternalOXtype.g:49: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;
+            // InternalOXtype.g:50:7: ( '@' )
+            // InternalOXtype.g:50: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;
+            // InternalOXtype.g:51:7: ( '(' )
+            // InternalOXtype.g:51: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;
+            // InternalOXtype.g:52:7: ( ')' )
+            // InternalOXtype.g:52: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;
+            // InternalOXtype.g:53:7: ( ',' )
+            // InternalOXtype.g:53: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;
+            // InternalOXtype.g:54:7: ( ']' )
+            // InternalOXtype.g:54: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;
+            // InternalOXtype.g:55:7: ( '#' )
+            // InternalOXtype.g:55: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;
+            // InternalOXtype.g:56:7: ( '[' )
+            // InternalOXtype.g:56: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;
+            // InternalOXtype.g:57:7: ( 'instanceof' )
+            // InternalOXtype.g:57:9: 'instanceof'
+            {
+            match("instanceof"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:58:7: ( 'as' )
+            // InternalOXtype.g:58:9: 'as'
+            {
+            match("as"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:59:7: ( '{' )
+            // InternalOXtype.g:59:9: '{'
+            {
+            match('{'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:60:7: ( '}' )
+            // InternalOXtype.g:60:9: '}'
+            {
+            match('}'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:61:7: ( 'if' )
+            // InternalOXtype.g:61:9: 'if'
+            {
+            match("if"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:62:7: ( 'else' )
+            // InternalOXtype.g:62:9: 'else'
+            {
+            match("else"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:63:7: ( 'switch' )
+            // InternalOXtype.g:63:9: 'switch'
+            {
+            match("switch"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:64:7: ( ':' )
+            // InternalOXtype.g:64: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;
+            // InternalOXtype.g:65:7: ( 'default' )
+            // InternalOXtype.g:65:9: 'default'
+            {
+            match("default"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:66:7: ( 'case' )
+            // InternalOXtype.g:66:9: 'case'
+            {
+            match("case"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:67:7: ( 'for' )
+            // InternalOXtype.g:67:9: 'for'
+            {
+            match("for"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:68:7: ( 'while' )
+            // InternalOXtype.g:68:9: 'while'
+            {
+            match("while"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:69:7: ( 'do' )
+            // InternalOXtype.g:69:9: 'do'
+            {
+            match("do"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:70:7: ( 'new' )
+            // InternalOXtype.g:70:9: 'new'
+            {
+            match("new"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:71:7: ( 'null' )
+            // InternalOXtype.g:71:9: 'null'
+            {
+            match("null"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:72:7: ( 'typeof' )
+            // InternalOXtype.g:72:9: 'typeof'
+            {
+            match("typeof"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:73:7: ( 'throw' )
+            // InternalOXtype.g:73:9: 'throw'
+            {
+            match("throw"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:74:7: ( 'return' )
+            // InternalOXtype.g:74:9: 'return'
+            {
+            match("return"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:75:7: ( 'try' )
+            // InternalOXtype.g:75:9: 'try'
+            {
+            match("try"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:76:7: ( 'finally' )
+            // InternalOXtype.g:76:9: 'finally'
+            {
+            match("finally"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:77:7: ( 'synchronized' )
+            // InternalOXtype.g:77:9: 'synchronized'
+            {
+            match("synchronized"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:78:7: ( 'catch' )
+            // InternalOXtype.g:78:9: 'catch'
+            {
+            match("catch"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:79:7: ( '?' )
+            // InternalOXtype.g:79:9: '?'
+            {
+            match('?'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:80:7: ( '&' )
+            // InternalOXtype.g:80:9: '&'
+            {
+            match('&'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:81:7: ( 'ns' )
+            // InternalOXtype.g:81:9: 'ns'
+            {
+            match("ns"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:82:7: ( '::' )
+            // InternalOXtype.g:82:9: '::'
+            {
+            match("::"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:83:7: ( '?.' )
+            // InternalOXtype.g:83:9: '?.'
+            {
+            match("?."); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:84:7: ( '|' )
+            // InternalOXtype.g:84:9: '|'
+            {
+            match('|'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:85:7: ( 'var' )
+            // InternalOXtype.g:85:9: 'var'
+            {
+            match("var"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:86:7: ( 'true' )
+            // InternalOXtype.g:86:9: 'true'
+            {
+            match("true"); 
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__88"
+
+    // $ANTLR start "RULE_HEX"
+    public final void mRULE_HEX() throws RecognitionException {
+        try {
+            int _type = RULE_HEX;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:18598:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? )
+            // InternalOXtype.g:18598:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+            {
+            // InternalOXtype.g:18598:12: ( '0x' | '0X' )
+            int alt1=2;
+            int LA1_0 = input.LA(1);
+
+            if ( (LA1_0=='0') ) {
+                int LA1_1 = input.LA(2);
+
+                if ( (LA1_1=='x') ) {
+                    alt1=1;
+                }
+                else if ( (LA1_1=='X') ) {
+                    alt1=2;
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 1, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 1, 0, input);
+
+                throw nvae;
+            }
+            switch (alt1) {
+                case 1 :
+                    // InternalOXtype.g:18598:13: '0x'
+                    {
+                    match("0x"); 
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:18598:18: '0X'
+                    {
+                    match("0X"); 
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:18598:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+
+            int cnt2=0;
+            loop2:
+            do {
+                int alt2=2;
+                int LA2_0 = input.LA(1);
+
+                if ( ((LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='F')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='f')) ) {
+                    alt2=1;
+                }
+
+
+                switch (alt2) {
+            	case 1 :
+            	    // InternalOXtype.g:
+            	    {
+            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    if ( cnt2 >= 1 ) break loop2;
+                        EarlyExitException eee =
+                            new EarlyExitException(2, input);
+                        throw eee;
+                }
+                cnt2++;
+            } while (true);
+
+            // InternalOXtype.g:18598:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+            int alt4=2;
+            int LA4_0 = input.LA(1);
+
+            if ( (LA4_0=='#') ) {
+                alt4=1;
+            }
+            switch (alt4) {
+                case 1 :
+                    // InternalOXtype.g:18598:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+                    {
+                    match('#'); 
+                    // InternalOXtype.g:18598:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+                    int alt3=2;
+                    int LA3_0 = input.LA(1);
+
+                    if ( (LA3_0=='B'||LA3_0=='b') ) {
+                        alt3=1;
+                    }
+                    else if ( (LA3_0=='L'||LA3_0=='l') ) {
+                        alt3=2;
+                    }
+                    else {
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 3, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt3) {
+                        case 1 :
+                            // InternalOXtype.g:18598:64: ( 'b' | 'B' ) ( 'i' | 'I' )
+                            {
+                            if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+                            if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:18598:84: ( 'l' | 'L' )
+                            {
+                            if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_HEX"
+
+    // $ANTLR start "RULE_INT"
+    public final void mRULE_INT() throws RecognitionException {
+        try {
+            int _type = RULE_INT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:18600:10: ( '0' .. '9' ( '0' .. '9' | '_' )* )
+            // InternalOXtype.g:18600:12: '0' .. '9' ( '0' .. '9' | '_' )*
+            {
+            matchRange('0','9'); 
+            // InternalOXtype.g:18600:21: ( '0' .. '9' | '_' )*
+            loop5:
+            do {
+                int alt5=2;
+                int LA5_0 = input.LA(1);
+
+                if ( ((LA5_0>='0' && LA5_0<='9')||LA5_0=='_') ) {
+                    alt5=1;
+                }
+
+
+                switch (alt5) {
+            	case 1 :
+            	    // InternalOXtype.g:
+            	    {
+            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop5;
+                }
+            } while (true);
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_INT"
+
+    // $ANTLR start "RULE_DECIMAL"
+    public final void mRULE_DECIMAL() throws RecognitionException {
+        try {
+            int _type = RULE_DECIMAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:18602:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? )
+            // InternalOXtype.g:18602:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+            {
+            mRULE_INT(); 
+            // InternalOXtype.g:18602:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )?
+            int alt7=2;
+            int LA7_0 = input.LA(1);
+
+            if ( (LA7_0=='E'||LA7_0=='e') ) {
+                alt7=1;
+            }
+            switch (alt7) {
+                case 1 :
+                    // InternalOXtype.g:18602:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT
+                    {
+                    if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+                    // InternalOXtype.g:18602:36: ( '+' | '-' )?
+                    int alt6=2;
+                    int LA6_0 = input.LA(1);
+
+                    if ( (LA6_0=='+'||LA6_0=='-') ) {
+                        alt6=1;
+                    }
+                    switch (alt6) {
+                        case 1 :
+                            // InternalOXtype.g:
+                            {
+                            if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+
+                            }
+                            break;
+
+                    }
+
+                    mRULE_INT(); 
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:18602:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+            int alt8=3;
+            int LA8_0 = input.LA(1);
+
+            if ( (LA8_0=='B'||LA8_0=='b') ) {
+                alt8=1;
+            }
+            else if ( (LA8_0=='D'||LA8_0=='F'||LA8_0=='L'||LA8_0=='d'||LA8_0=='f'||LA8_0=='l') ) {
+                alt8=2;
+            }
+            switch (alt8) {
+                case 1 :
+                    // InternalOXtype.g:18602:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' )
+                    {
+                    if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+                    if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:18602:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' )
+                    {
+                    if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_DECIMAL"
+
+    // $ANTLR start "RULE_ID"
+    public final void mRULE_ID() throws RecognitionException {
+        try {
+            int _type = RULE_ID;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:18604:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* )
+            // InternalOXtype.g:18604:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+            {
+            // InternalOXtype.g:18604:11: ( '^' )?
+            int alt9=2;
+            int LA9_0 = input.LA(1);
+
+            if ( (LA9_0=='^') ) {
+                alt9=1;
+            }
+            switch (alt9) {
+                case 1 :
+                    // InternalOXtype.g:18604:11: '^'
+                    {
+                    match('^'); 
+
+                    }
+                    break;
+
+            }
+
+            if ( input.LA(1)=='$'||(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;}
+
+            // InternalOXtype.g:18604:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+            loop10:
+            do {
+                int alt10=2;
+                int LA10_0 = input.LA(1);
+
+                if ( (LA10_0=='$'||(LA10_0>='0' && LA10_0<='9')||(LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='a' && LA10_0<='z')) ) {
+                    alt10=1;
+                }
+
+
+                switch (alt10) {
+            	case 1 :
+            	    // InternalOXtype.g:
+            	    {
+            	    if ( input.LA(1)=='$'||(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 loop10;
+                }
+            } while (true);
+
+
+            }
+
+            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;
+            // InternalOXtype.g:18606:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) )
+            // InternalOXtype.g:18606:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+            {
+            // InternalOXtype.g:18606:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+            int alt15=2;
+            int LA15_0 = input.LA(1);
+
+            if ( (LA15_0=='\"') ) {
+                alt15=1;
+            }
+            else if ( (LA15_0=='\'') ) {
+                alt15=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 15, 0, input);
+
+                throw nvae;
+            }
+            switch (alt15) {
+                case 1 :
+                    // InternalOXtype.g:18606:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )?
+                    {
+                    match('\"'); 
+                    // InternalOXtype.g:18606:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    loop11:
+                    do {
+                        int alt11=3;
+                        int LA11_0 = input.LA(1);
+
+                        if ( (LA11_0=='\\') ) {
+                            alt11=1;
+                        }
+                        else if ( ((LA11_0>='\u0000' && LA11_0<='!')||(LA11_0>='#' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {
+                            alt11=2;
+                        }
+
+
+                        switch (alt11) {
+                    	case 1 :
+                    	    // InternalOXtype.g:18606:21: '\\\\' .
+                    	    {
+                    	    match('\\'); 
+                    	    matchAny(); 
+
+                    	    }
+                    	    break;
+                    	case 2 :
+                    	    // InternalOXtype.g:18606:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    {
+                    	    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 loop11;
+                        }
+                    } while (true);
+
+                    // InternalOXtype.g:18606:44: ( '\"' )?
+                    int alt12=2;
+                    int LA12_0 = input.LA(1);
+
+                    if ( (LA12_0=='\"') ) {
+                        alt12=1;
+                    }
+                    switch (alt12) {
+                        case 1 :
+                            // InternalOXtype.g:18606:44: '\"'
+                            {
+                            match('\"'); 
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:18606:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )?
+                    {
+                    match('\''); 
+                    // InternalOXtype.g:18606:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    loop13:
+                    do {
+                        int alt13=3;
+                        int LA13_0 = input.LA(1);
+
+                        if ( (LA13_0=='\\') ) {
+                            alt13=1;
+                        }
+                        else if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) {
+                            alt13=2;
+                        }
+
+
+                        switch (alt13) {
+                    	case 1 :
+                    	    // InternalOXtype.g:18606:55: '\\\\' .
+                    	    {
+                    	    match('\\'); 
+                    	    matchAny(); 
+
+                    	    }
+                    	    break;
+                    	case 2 :
+                    	    // InternalOXtype.g:18606:62: ~ ( ( '\\\\' | '\\'' ) )
+                    	    {
+                    	    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 loop13;
+                        }
+                    } while (true);
+
+                    // InternalOXtype.g:18606:79: ( '\\'' )?
+                    int alt14=2;
+                    int LA14_0 = input.LA(1);
+
+                    if ( (LA14_0=='\'') ) {
+                        alt14=1;
+                    }
+                    switch (alt14) {
+                        case 1 :
+                            // InternalOXtype.g:18606:79: '\\''
+                            {
+                            match('\''); 
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            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;
+            // InternalOXtype.g:18608:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalOXtype.g:18608:19: '/*' ( options {greedy=false; } : . )* '*/'
+            {
+            match("/*"); 
+
+            // InternalOXtype.g:18608:24: ( options {greedy=false; } : . )*
+            loop16:
+            do {
+                int alt16=2;
+                int LA16_0 = input.LA(1);
+
+                if ( (LA16_0=='*') ) {
+                    int LA16_1 = input.LA(2);
+
+                    if ( (LA16_1=='/') ) {
+                        alt16=2;
+                    }
+                    else if ( ((LA16_1>='\u0000' && LA16_1<='.')||(LA16_1>='0' && LA16_1<='\uFFFF')) ) {
+                        alt16=1;
+                    }
+
+
+                }
+                else if ( ((LA16_0>='\u0000' && LA16_0<=')')||(LA16_0>='+' && LA16_0<='\uFFFF')) ) {
+                    alt16=1;
+                }
+
+
+                switch (alt16) {
+            	case 1 :
+            	    // InternalOXtype.g:18608:52: .
+            	    {
+            	    matchAny(); 
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop16;
+                }
+            } 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;
+            // InternalOXtype.g:18610:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalOXtype.g:18610:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            {
+            match("//"); 
+
+            // InternalOXtype.g:18610:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            loop17:
+            do {
+                int alt17=2;
+                int LA17_0 = input.LA(1);
+
+                if ( ((LA17_0>='\u0000' && LA17_0<='\t')||(LA17_0>='\u000B' && LA17_0<='\f')||(LA17_0>='\u000E' && LA17_0<='\uFFFF')) ) {
+                    alt17=1;
+                }
+
+
+                switch (alt17) {
+            	case 1 :
+            	    // InternalOXtype.g:18610: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)<='\uFFFF') ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop17;
+                }
+            } while (true);
+
+            // InternalOXtype.g:18610:40: ( ( '\\r' )? '\\n' )?
+            int alt19=2;
+            int LA19_0 = input.LA(1);
+
+            if ( (LA19_0=='\n'||LA19_0=='\r') ) {
+                alt19=1;
+            }
+            switch (alt19) {
+                case 1 :
+                    // InternalOXtype.g:18610:41: ( '\\r' )? '\\n'
+                    {
+                    // InternalOXtype.g:18610:41: ( '\\r' )?
+                    int alt18=2;
+                    int LA18_0 = input.LA(1);
+
+                    if ( (LA18_0=='\r') ) {
+                        alt18=1;
+                    }
+                    switch (alt18) {
+                        case 1 :
+                            // InternalOXtype.g:18610:41: '\\r'
+                            {
+                            match('\r'); 
+
+                            }
+                            break;
+
+                    }
+
+                    match('\n'); 
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_SL_COMMENT"
+
+    // $ANTLR start "RULE_WS"
+    public final void mRULE_WS() throws RecognitionException {
+        try {
+            int _type = RULE_WS;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:18612:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalOXtype.g:18612:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            {
+            // InternalOXtype.g:18612:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            int cnt20=0;
+            loop20:
+            do {
+                int alt20=2;
+                int LA20_0 = input.LA(1);
+
+                if ( ((LA20_0>='\t' && LA20_0<='\n')||LA20_0=='\r'||LA20_0==' ') ) {
+                    alt20=1;
+                }
+
+
+                switch (alt20) {
+            	case 1 :
+            	    // InternalOXtype.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 ( cnt20 >= 1 ) break loop20;
+                        EarlyExitException eee =
+                            new EarlyExitException(20, input);
+                        throw eee;
+                }
+                cnt20++;
+            } 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;
+            // InternalOXtype.g:18614:16: ( . )
+            // InternalOXtype.g:18614:18: .
+            {
+            matchAny(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_ANY_OTHER"
+
+    public void mTokens() throws RecognitionException {
+        // InternalOXtype.g:1:8: ( 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 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
+        int alt21=85;
+        alt21 = dfa21.predict(input);
+        switch (alt21) {
+            case 1 :
+                // InternalOXtype.g:1:10: T__13
+                {
+                mT__13(); 
+
+                }
+                break;
+            case 2 :
+                // InternalOXtype.g:1:16: T__14
+                {
+                mT__14(); 
+
+                }
+                break;
+            case 3 :
+                // InternalOXtype.g:1:22: T__15
+                {
+                mT__15(); 
+
+                }
+                break;
+            case 4 :
+                // InternalOXtype.g:1:28: T__16
+                {
+                mT__16(); 
+
+                }
+                break;
+            case 5 :
+                // InternalOXtype.g:1:34: T__17
+                {
+                mT__17(); 
+
+                }
+                break;
+            case 6 :
+                // InternalOXtype.g:1:40: T__18
+                {
+                mT__18(); 
+
+                }
+                break;
+            case 7 :
+                // InternalOXtype.g:1:46: T__19
+                {
+                mT__19(); 
+
+                }
+                break;
+            case 8 :
+                // InternalOXtype.g:1:52: T__20
+                {
+                mT__20(); 
+
+                }
+                break;
+            case 9 :
+                // InternalOXtype.g:1:58: T__21
+                {
+                mT__21(); 
+
+                }
+                break;
+            case 10 :
+                // InternalOXtype.g:1:64: T__22
+                {
+                mT__22(); 
+
+                }
+                break;
+            case 11 :
+                // InternalOXtype.g:1:70: T__23
+                {
+                mT__23(); 
+
+                }
+                break;
+            case 12 :
+                // InternalOXtype.g:1:76: T__24
+                {
+                mT__24(); 
+
+                }
+                break;
+            case 13 :
+                // InternalOXtype.g:1:82: T__25
+                {
+                mT__25(); 
+
+                }
+                break;
+            case 14 :
+                // InternalOXtype.g:1:88: T__26
+                {
+                mT__26(); 
+
+                }
+                break;
+            case 15 :
+                // InternalOXtype.g:1:94: T__27
+                {
+                mT__27(); 
+
+                }
+                break;
+            case 16 :
+                // InternalOXtype.g:1:100: T__28
+                {
+                mT__28(); 
+
+                }
+                break;
+            case 17 :
+                // InternalOXtype.g:1:106: T__29
+                {
+                mT__29(); 
+
+                }
+                break;
+            case 18 :
+                // InternalOXtype.g:1:112: T__30
+                {
+                mT__30(); 
+
+                }
+                break;
+            case 19 :
+                // InternalOXtype.g:1:118: T__31
+                {
+                mT__31(); 
+
+                }
+                break;
+            case 20 :
+                // InternalOXtype.g:1:124: T__32
+                {
+                mT__32(); 
+
+                }
+                break;
+            case 21 :
+                // InternalOXtype.g:1:130: T__33
+                {
+                mT__33(); 
+
+                }
+                break;
+            case 22 :
+                // InternalOXtype.g:1:136: T__34
+                {
+                mT__34(); 
+
+                }
+                break;
+            case 23 :
+                // InternalOXtype.g:1:142: T__35
+                {
+                mT__35(); 
+
+                }
+                break;
+            case 24 :
+                // InternalOXtype.g:1:148: T__36
+                {
+                mT__36(); 
+
+                }
+                break;
+            case 25 :
+                // InternalOXtype.g:1:154: T__37
+                {
+                mT__37(); 
+
+                }
+                break;
+            case 26 :
+                // InternalOXtype.g:1:160: T__38
+                {
+                mT__38(); 
+
+                }
+                break;
+            case 27 :
+                // InternalOXtype.g:1:166: T__39
+                {
+                mT__39(); 
+
+                }
+                break;
+            case 28 :
+                // InternalOXtype.g:1:172: T__40
+                {
+                mT__40(); 
+
+                }
+                break;
+            case 29 :
+                // InternalOXtype.g:1:178: T__41
+                {
+                mT__41(); 
+
+                }
+                break;
+            case 30 :
+                // InternalOXtype.g:1:184: T__42
+                {
+                mT__42(); 
+
+                }
+                break;
+            case 31 :
+                // InternalOXtype.g:1:190: T__43
+                {
+                mT__43(); 
+
+                }
+                break;
+            case 32 :
+                // InternalOXtype.g:1:196: T__44
+                {
+                mT__44(); 
+
+                }
+                break;
+            case 33 :
+                // InternalOXtype.g:1:202: T__45
+                {
+                mT__45(); 
+
+                }
+                break;
+            case 34 :
+                // InternalOXtype.g:1:208: T__46
+                {
+                mT__46(); 
+
+                }
+                break;
+            case 35 :
+                // InternalOXtype.g:1:214: T__47
+                {
+                mT__47(); 
+
+                }
+                break;
+            case 36 :
+                // InternalOXtype.g:1:220: T__48
+                {
+                mT__48(); 
+
+                }
+                break;
+            case 37 :
+                // InternalOXtype.g:1:226: T__49
+                {
+                mT__49(); 
+
+                }
+                break;
+            case 38 :
+                // InternalOXtype.g:1:232: T__50
+                {
+                mT__50(); 
+
+                }
+                break;
+            case 39 :
+                // InternalOXtype.g:1:238: T__51
+                {
+                mT__51(); 
+
+                }
+                break;
+            case 40 :
+                // InternalOXtype.g:1:244: T__52
+                {
+                mT__52(); 
+
+                }
+                break;
+            case 41 :
+                // InternalOXtype.g:1:250: T__53
+                {
+                mT__53(); 
+
+                }
+                break;
+            case 42 :
+                // InternalOXtype.g:1:256: T__54
+                {
+                mT__54(); 
+
+                }
+                break;
+            case 43 :
+                // InternalOXtype.g:1:262: T__55
+                {
+                mT__55(); 
+
+                }
+                break;
+            case 44 :
+                // InternalOXtype.g:1:268: T__56
+                {
+                mT__56(); 
+
+                }
+                break;
+            case 45 :
+                // InternalOXtype.g:1:274: T__57
+                {
+                mT__57(); 
+
+                }
+                break;
+            case 46 :
+                // InternalOXtype.g:1:280: T__58
+                {
+                mT__58(); 
+
+                }
+                break;
+            case 47 :
+                // InternalOXtype.g:1:286: T__59
+                {
+                mT__59(); 
+
+                }
+                break;
+            case 48 :
+                // InternalOXtype.g:1:292: T__60
+                {
+                mT__60(); 
+
+                }
+                break;
+            case 49 :
+                // InternalOXtype.g:1:298: T__61
+                {
+                mT__61(); 
+
+                }
+                break;
+            case 50 :
+                // InternalOXtype.g:1:304: T__62
+                {
+                mT__62(); 
+
+                }
+                break;
+            case 51 :
+                // InternalOXtype.g:1:310: T__63
+                {
+                mT__63(); 
+
+                }
+                break;
+            case 52 :
+                // InternalOXtype.g:1:316: T__64
+                {
+                mT__64(); 
+
+                }
+                break;
+            case 53 :
+                // InternalOXtype.g:1:322: T__65
+                {
+                mT__65(); 
+
+                }
+                break;
+            case 54 :
+                // InternalOXtype.g:1:328: T__66
+                {
+                mT__66(); 
+
+                }
+                break;
+            case 55 :
+                // InternalOXtype.g:1:334: T__67
+                {
+                mT__67(); 
+
+                }
+                break;
+            case 56 :
+                // InternalOXtype.g:1:340: T__68
+                {
+                mT__68(); 
+
+                }
+                break;
+            case 57 :
+                // InternalOXtype.g:1:346: T__69
+                {
+                mT__69(); 
+
+                }
+                break;
+            case 58 :
+                // InternalOXtype.g:1:352: T__70
+                {
+                mT__70(); 
+
+                }
+                break;
+            case 59 :
+                // InternalOXtype.g:1:358: T__71
+                {
+                mT__71(); 
+
+                }
+                break;
+            case 60 :
+                // InternalOXtype.g:1:364: T__72
+                {
+                mT__72(); 
+
+                }
+                break;
+            case 61 :
+                // InternalOXtype.g:1:370: T__73
+                {
+                mT__73(); 
+
+                }
+                break;
+            case 62 :
+                // InternalOXtype.g:1:376: T__74
+                {
+                mT__74(); 
+
+                }
+                break;
+            case 63 :
+                // InternalOXtype.g:1:382: T__75
+                {
+                mT__75(); 
+
+                }
+                break;
+            case 64 :
+                // InternalOXtype.g:1:388: T__76
+                {
+                mT__76(); 
+
+                }
+                break;
+            case 65 :
+                // InternalOXtype.g:1:394: T__77
+                {
+                mT__77(); 
+
+                }
+                break;
+            case 66 :
+                // InternalOXtype.g:1:400: T__78
+                {
+                mT__78(); 
+
+                }
+                break;
+            case 67 :
+                // InternalOXtype.g:1:406: T__79
+                {
+                mT__79(); 
+
+                }
+                break;
+            case 68 :
+                // InternalOXtype.g:1:412: T__80
+                {
+                mT__80(); 
+
+                }
+                break;
+            case 69 :
+                // InternalOXtype.g:1:418: T__81
+                {
+                mT__81(); 
+
+                }
+                break;
+            case 70 :
+                // InternalOXtype.g:1:424: T__82
+                {
+                mT__82(); 
+
+                }
+                break;
+            case 71 :
+                // InternalOXtype.g:1:430: T__83
+                {
+                mT__83(); 
+
+                }
+                break;
+            case 72 :
+                // InternalOXtype.g:1:436: T__84
+                {
+                mT__84(); 
+
+                }
+                break;
+            case 73 :
+                // InternalOXtype.g:1:442: T__85
+                {
+                mT__85(); 
+
+                }
+                break;
+            case 74 :
+                // InternalOXtype.g:1:448: T__86
+                {
+                mT__86(); 
+
+                }
+                break;
+            case 75 :
+                // InternalOXtype.g:1:454: T__87
+                {
+                mT__87(); 
+
+                }
+                break;
+            case 76 :
+                // InternalOXtype.g:1:460: T__88
+                {
+                mT__88(); 
+
+                }
+                break;
+            case 77 :
+                // InternalOXtype.g:1:466: RULE_HEX
+                {
+                mRULE_HEX(); 
+
+                }
+                break;
+            case 78 :
+                // InternalOXtype.g:1:475: RULE_INT
+                {
+                mRULE_INT(); 
+
+                }
+                break;
+            case 79 :
+                // InternalOXtype.g:1:484: RULE_DECIMAL
+                {
+                mRULE_DECIMAL(); 
+
+                }
+                break;
+            case 80 :
+                // InternalOXtype.g:1:497: RULE_ID
+                {
+                mRULE_ID(); 
+
+                }
+                break;
+            case 81 :
+                // InternalOXtype.g:1:505: RULE_STRING
+                {
+                mRULE_STRING(); 
+
+                }
+                break;
+            case 82 :
+                // InternalOXtype.g:1:517: RULE_ML_COMMENT
+                {
+                mRULE_ML_COMMENT(); 
+
+                }
+                break;
+            case 83 :
+                // InternalOXtype.g:1:533: RULE_SL_COMMENT
+                {
+                mRULE_SL_COMMENT(); 
+
+                }
+                break;
+            case 84 :
+                // InternalOXtype.g:1:549: RULE_WS
+                {
+                mRULE_WS(); 
+
+                }
+                break;
+            case 85 :
+                // InternalOXtype.g:1:557: RULE_ANY_OTHER
+                {
+                mRULE_ANY_OTHER(); 
+
+                }
+                break;
+
+        }
+
+    }
+
+
+    protected DFA21 dfa21 = new DFA21(this);
+    static final String DFA21_eotS =
+        "\1\uffff\1\57\1\61\1\63\1\66\1\72\1\75\1\101\1\103\1\105\1\107\1\111\1\113\1\116\5\120\10\uffff\1\120\2\uffff\1\151\6\120\2\167\1\54\5\uffff\1\174\26\uffff\1\176\5\uffff\1\u0080\4\uffff\1\120\1\uffff\10\120\1\u008b\3\120\10\uffff\1\u008f\4\uffff\1\120\1\u0091\4\120\1\u0097\4\120\1\uffff\1\167\12\uffff\1\u009d\1\u009e\10\120\1\uffff\1\120\1\u00a8\1\120\1\uffff\1\120\1\uffff\3\120\1\u00ae\1\120\1\uffff\2\120\1\u00b2\2\120\2\uffff\1\120\1\u00b6\7\120\1\uffff\2\120\1\u00c0\2\120\1\uffff\1\u00c3\2\120\1\uffff\1\u00c6\2\120\1\uffff\1\120\1\u00cb\4\120\1\u00d0\2\120\1\uffff\1\u00d3\1\u00d4\1\uffff\1\120\1\u00d6\1\uffff\3\120\1\u00da\1\uffff\1\u00db\1\120\1\u00dd\1\120\1\uffff\2\120\2\uffff\1\u00e1\1\uffff\1\u00e2\1\u00e3\1\120\2\uffff\1\120\1\uffff\1\120\1\u00e7\1\u00e8\3\uffff\3\120\2\uffff\1\u00ec\2\120\1\uffff\1\120\1\u00f0\1\120\1\uffff\1\u00f2\1\uffff";
+    static final String DFA21_eofS =
+        "\u00f3\uffff";
+    static final String DFA21_minS =
+        "\1\0\1\75\1\174\1\46\1\53\1\55\2\52\3\75\1\76\2\56\1\141\1\154\1\164\1\146\1\141\10\uffff\1\163\2\uffff\1\72\1\145\1\141\1\150\1\145\1\150\1\145\2\60\1\44\5\uffff\1\75\26\uffff\1\75\5\uffff\1\74\4\uffff\1\154\1\uffff\1\164\1\163\1\141\1\160\1\151\1\156\1\160\1\163\1\44\1\154\1\162\1\156\10\uffff\1\44\4\uffff\1\146\1\44\1\163\1\151\1\167\1\154\1\44\1\160\1\162\1\165\1\164\1\uffff\1\60\12\uffff\2\44\2\145\1\164\1\145\1\164\1\143\1\157\1\164\1\uffff\1\163\1\44\1\141\1\uffff\1\141\1\uffff\1\145\1\143\1\154\1\44\1\154\1\uffff\1\145\1\157\1\44\1\145\1\165\2\uffff\1\156\1\44\1\151\1\162\1\143\1\150\1\162\1\141\1\145\1\uffff\1\154\1\165\1\44\1\150\1\145\1\uffff\1\44\1\157\1\167\1\uffff\1\44\1\162\1\144\1\uffff\1\143\1\44\1\150\1\162\1\164\1\156\1\44\2\154\1\uffff\2\44\1\uffff\1\146\1\44\1\uffff\1\156\1\163\1\151\1\44\1\uffff\1\44\1\157\1\44\1\143\1\uffff\1\171\1\164\2\uffff\1\44\1\uffff\2\44\1\157\2\uffff\1\156\1\uffff\1\145\2\44\3\uffff\1\156\1\151\1\157\2\uffff\1\44\1\172\1\146\1\uffff\1\145\1\44\1\144\1\uffff\1\44\1\uffff";
+    static final String DFA21_maxS =
+        "\1\uffff\1\76\1\174\1\46\1\75\1\76\5\75\1\76\1\56\1\72\1\141\1\170\1\171\1\156\1\157\10\uffff\1\163\2\uffff\1\72\1\157\1\141\1\150\1\165\1\171\1\145\1\170\1\154\1\172\5\uffff\1\75\26\uffff\1\75\5\uffff\1\74\4\uffff\1\162\1\uffff\1\164\1\163\1\141\1\160\1\151\1\156\1\160\1\163\1\172\1\154\1\162\1\156\10\uffff\1\172\4\uffff\1\146\1\172\1\164\1\151\1\167\1\154\1\172\1\160\1\162\1\171\1\164\1\uffff\1\154\12\uffff\2\172\2\145\1\164\1\145\1\164\1\143\1\157\1\164\1\uffff\1\163\1\172\1\141\1\uffff\1\141\1\uffff\1\145\1\143\1\154\1\172\1\154\1\uffff\1\145\1\157\1\172\1\145\1\165\2\uffff\1\156\1\172\1\151\1\162\1\143\1\150\1\162\1\141\1\145\1\uffff\1\154\1\165\1\172\1\150\1\145\1\uffff\1\172\1\157\1\167\1\uffff\1\172\1\162\1\163\1\uffff\1\143\1\172\1\150\1\162\1\164\1\156\1\172\2\154\1\uffff\2\172\1\uffff\1\146\1\172\1\uffff\1\156\1\163\1\151\1\172\1\uffff\1\172\1\157\1\172\1\143\1\uffff\1\171\1\164\2\uffff\1\172\1\uffff\2\172\1\157\2\uffff\1\156\1\uffff\1\145\2\172\3\uffff\1\156\1\151\1\157\2\uffff\2\172\1\146\1\uffff\1\145\1\172\1\144\1\uffff\1\172\1\uffff";
+    static final String DFA21_acceptS =
+        "\23\uffff\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\uffff\1\61\1\62\12\uffff\1\120\2\121\1\124\1\125\1\uffff\1\23\1\1\1\2\1\112\1\3\1\106\1\4\1\35\1\26\1\5\1\20\1\36\1\27\1\6\1\31\1\30\1\7\1\122\1\123\1\32\1\10\1\33\1\uffff\1\34\1\15\1\16\1\24\1\17\1\uffff\1\37\1\25\1\111\1\105\1\uffff\1\120\14\uffff\1\47\1\50\1\51\1\52\1\53\1\54\1\55\1\56\1\uffff\1\61\1\62\1\110\1\66\13\uffff\1\115\1\uffff\1\116\1\117\1\121\1\124\1\13\1\11\1\14\1\12\1\21\1\22\12\uffff\1\63\3\uffff\1\60\1\uffff\1\73\5\uffff\1\107\5\uffff\1\40\1\113\11\uffff\1\71\5\uffff\1\74\3\uffff\1\101\3\uffff\1\64\11\uffff\1\70\2\uffff\1\75\2\uffff\1\114\4\uffff\1\45\4\uffff\1\46\2\uffff\1\104\1\72\1\uffff\1\77\3\uffff\1\42\1\65\1\uffff\1\43\3\uffff\1\76\1\100\1\41\3\uffff\1\102\1\67\3\uffff\1\44\3\uffff\1\57\1\uffff\1\103";
+    static final String DFA21_specialS =
+        "\1\0\u00f2\uffff}>";
+    static final String[] DFA21_transitionS = {
+            "\11\54\2\53\2\54\1\53\22\54\1\53\1\11\1\51\1\31\1\50\1\10\1\3\1\52\1\25\1\26\1\6\1\4\1\27\1\5\1\14\1\7\1\45\11\46\1\36\1\23\1\13\1\1\1\12\1\15\1\24\32\50\1\32\1\54\1\30\1\47\1\50\1\54\1\33\1\50\1\40\1\37\1\17\1\22\2\50\1\21\4\50\1\42\3\50\1\44\1\20\1\43\1\50\1\16\1\41\3\50\1\34\1\2\1\35\uff82\54",
+            "\1\55\1\56",
+            "\1\60",
+            "\1\62",
+            "\1\65\21\uffff\1\64",
+            "\1\71\17\uffff\1\67\1\70",
+            "\1\74\22\uffff\1\73",
+            "\1\77\4\uffff\1\100\15\uffff\1\76",
+            "\1\102",
+            "\1\104",
+            "\1\106",
+            "\1\110",
+            "\1\112",
+            "\1\115\13\uffff\1\114",
+            "\1\117",
+            "\1\122\13\uffff\1\121",
+            "\1\123\1\124\1\uffff\1\125\1\uffff\1\126",
+            "\1\131\6\uffff\1\127\1\130",
+            "\1\132\7\uffff\1\134\5\uffff\1\133",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\145",
+            "",
+            "",
+            "\1\150",
+            "\1\152\11\uffff\1\153",
+            "\1\154",
+            "\1\155",
+            "\1\156\15\uffff\1\160\1\uffff\1\157",
+            "\1\162\11\uffff\1\163\6\uffff\1\161",
+            "\1\164",
+            "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165\6\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165",
+            "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+            "\1\120\34\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\173",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\175",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\177",
+            "",
+            "",
+            "",
+            "",
+            "\1\u0081\5\uffff\1\u0082",
+            "",
+            "\1\u0083",
+            "\1\u0084",
+            "\1\u0085",
+            "\1\u0086",
+            "\1\u0087",
+            "\1\u0088",
+            "\1\u0089",
+            "\1\u008a",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u008c",
+            "\1\u008d",
+            "\1\u008e",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "",
+            "",
+            "",
+            "\1\u0090",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u0092\1\u0093",
+            "\1\u0094",
+            "\1\u0095",
+            "\1\u0096",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u0098",
+            "\1\u0099",
+            "\1\u009b\3\uffff\1\u009a",
+            "\1\u009c",
+            "",
+            "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u009f",
+            "\1\u00a0",
+            "\1\u00a1",
+            "\1\u00a2",
+            "\1\u00a3",
+            "\1\u00a4",
+            "\1\u00a5",
+            "\1\u00a6",
+            "",
+            "\1\u00a7",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00a9",
+            "",
+            "\1\u00aa",
+            "",
+            "\1\u00ab",
+            "\1\u00ac",
+            "\1\u00ad",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00af",
+            "",
+            "\1\u00b0",
+            "\1\u00b1",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00b3",
+            "\1\u00b4",
+            "",
+            "",
+            "\1\u00b5",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00b7",
+            "\1\u00b8",
+            "\1\u00b9",
+            "\1\u00ba",
+            "\1\u00bb",
+            "\1\u00bc",
+            "\1\u00bd",
+            "",
+            "\1\u00be",
+            "\1\u00bf",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00c1",
+            "\1\u00c2",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00c4",
+            "\1\u00c5",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00c7",
+            "\1\u00c8\16\uffff\1\u00c9",
+            "",
+            "\1\u00ca",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00cc",
+            "\1\u00cd",
+            "\1\u00ce",
+            "\1\u00cf",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00d1",
+            "\1\u00d2",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "\1\u00d5",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "\1\u00d7",
+            "\1\u00d8",
+            "\1\u00d9",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00dc",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00de",
+            "",
+            "\1\u00df",
+            "\1\u00e0",
+            "",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00e4",
+            "",
+            "",
+            "\1\u00e5",
+            "",
+            "\1\u00e6",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "",
+            "",
+            "",
+            "\1\u00e9",
+            "\1\u00ea",
+            "\1\u00eb",
+            "",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00ed",
+            "\1\u00ee",
+            "",
+            "\1\u00ef",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            "\1\u00f1",
+            "",
+            "\1\120\13\uffff\12\120\7\uffff\32\120\4\uffff\1\120\1\uffff\32\120",
+            ""
+    };
+
+    static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
+    static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
+    static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS);
+    static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS);
+    static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
+    static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS);
+    static final short[][] DFA21_transition;
+
+    static {
+        int numStates = DFA21_transitionS.length;
+        DFA21_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA21_transition[i] = DFA.unpackEncodedString(DFA21_transitionS[i]);
+        }
+    }
+
+    class DFA21 extends DFA {
+
+        public DFA21(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 21;
+            this.eot = DFA21_eot;
+            this.eof = DFA21_eof;
+            this.min = DFA21_min;
+            this.max = DFA21_max;
+            this.accept = DFA21_accept;
+            this.special = DFA21_special;
+            this.transition = DFA21_transition;
+        }
+        public String getDescription() {
+            return "1:1: Tokens : ( 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 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | 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 LA21_0 = input.LA(1);
+
+                        s = -1;
+                        if ( (LA21_0=='=') ) {s = 1;}
+
+                        else if ( (LA21_0=='|') ) {s = 2;}
+
+                        else if ( (LA21_0=='&') ) {s = 3;}
+
+                        else if ( (LA21_0=='+') ) {s = 4;}
+
+                        else if ( (LA21_0=='-') ) {s = 5;}
+
+                        else if ( (LA21_0=='*') ) {s = 6;}
+
+                        else if ( (LA21_0=='/') ) {s = 7;}
+
+                        else if ( (LA21_0=='%') ) {s = 8;}
+
+                        else if ( (LA21_0=='!') ) {s = 9;}
+
+                        else if ( (LA21_0=='>') ) {s = 10;}
+
+                        else if ( (LA21_0=='<') ) {s = 11;}
+
+                        else if ( (LA21_0=='.') ) {s = 12;}
+
+                        else if ( (LA21_0=='?') ) {s = 13;}
+
+                        else if ( (LA21_0=='v') ) {s = 14;}
+
+                        else if ( (LA21_0=='e') ) {s = 15;}
+
+                        else if ( (LA21_0=='s') ) {s = 16;}
+
+                        else if ( (LA21_0=='i') ) {s = 17;}
+
+                        else if ( (LA21_0=='f') ) {s = 18;}
+
+                        else if ( (LA21_0==';') ) {s = 19;}
+
+                        else if ( (LA21_0=='@') ) {s = 20;}
+
+                        else if ( (LA21_0=='(') ) {s = 21;}
+
+                        else if ( (LA21_0==')') ) {s = 22;}
+
+                        else if ( (LA21_0==',') ) {s = 23;}
+
+                        else if ( (LA21_0==']') ) {s = 24;}
+
+                        else if ( (LA21_0=='#') ) {s = 25;}
+
+                        else if ( (LA21_0=='[') ) {s = 26;}
+
+                        else if ( (LA21_0=='a') ) {s = 27;}
+
+                        else if ( (LA21_0=='{') ) {s = 28;}
+
+                        else if ( (LA21_0=='}') ) {s = 29;}
+
+                        else if ( (LA21_0==':') ) {s = 30;}
+
+                        else if ( (LA21_0=='d') ) {s = 31;}
+
+                        else if ( (LA21_0=='c') ) {s = 32;}
+
+                        else if ( (LA21_0=='w') ) {s = 33;}
+
+                        else if ( (LA21_0=='n') ) {s = 34;}
+
+                        else if ( (LA21_0=='t') ) {s = 35;}
+
+                        else if ( (LA21_0=='r') ) {s = 36;}
+
+                        else if ( (LA21_0=='0') ) {s = 37;}
+
+                        else if ( ((LA21_0>='1' && LA21_0<='9')) ) {s = 38;}
+
+                        else if ( (LA21_0=='^') ) {s = 39;}
+
+                        else if ( (LA21_0=='$'||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||LA21_0=='b'||(LA21_0>='g' && LA21_0<='h')||(LA21_0>='j' && LA21_0<='m')||(LA21_0>='o' && LA21_0<='q')||LA21_0=='u'||(LA21_0>='x' && LA21_0<='z')) ) {s = 40;}
+
+                        else if ( (LA21_0=='\"') ) {s = 41;}
+
+                        else if ( (LA21_0=='\'') ) {s = 42;}
+
+                        else if ( ((LA21_0>='\t' && LA21_0<='\n')||LA21_0=='\r'||LA21_0==' ') ) {s = 43;}
+
+                        else if ( ((LA21_0>='\u0000' && LA21_0<='\b')||(LA21_0>='\u000B' && LA21_0<='\f')||(LA21_0>='\u000E' && LA21_0<='\u001F')||LA21_0=='\\'||LA21_0=='`'||(LA21_0>='~' && LA21_0<='\uFFFF')) ) {s = 44;}
+
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 21, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+ 
+
+}
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeParser.java b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeParser.java
new file mode 100644
index 0000000..9970d8c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src-gen/org/eclipse/osbp/xtext/oxtype/ide/contentassist/antlr/internal/InternalOXtypeParser.java
@@ -0,0 +1,64524 @@
+package org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal;
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalOXtypeParser extends AbstractInternalContentAssistParser {
+    public static final String[] tokenNames = new String[] {
+        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'='", "'||'", "'&&'", "'+='", "'-='", "'*='", "'/='", "'%='", "'=='", "'!='", "'==='", "'!=='", "'>='", "'>'", "'<'", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'+'", "'-'", "'*'", "'**'", "'/'", "'%'", "'!'", "'++'", "'--'", "'.'", "'val'", "'extends'", "'static'", "'import'", "'extension'", "'super'", "'false'", "';'", "'@'", "'('", "')'", "','", "']'", "'#'", "'['", "'instanceof'", "'as'", "'{'", "'}'", "'if'", "'else'", "'switch'", "':'", "'default'", "'case'", "'for'", "'while'", "'do'", "'new'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'?'", "'&'", "'ns'", "'::'", "'?.'", "'|'", "'var'", "'true'"
+    };
+    public static final int RULE_HEX=5;
+    public static final int T__50=50;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__59=59;
+    public static final int T__16=16;
+    public static final int T__17=17;
+    public static final int T__18=18;
+    public static final int T__55=55;
+    public static final int T__56=56;
+    public static final int T__13=13;
+    public static final int T__57=57;
+    public static final int T__14=14;
+    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__60=60;
+    public static final int T__61=61;
+    public static final int RULE_ID=4;
+    public static final int RULE_DECIMAL=7;
+    public static final int T__26=26;
+    public static final int T__27=27;
+    public static final int T__28=28;
+    public static final int RULE_INT=6;
+    public static final int T__29=29;
+    public static final int T__22=22;
+    public static final int T__66=66;
+    public static final int RULE_ML_COMMENT=9;
+    public static final int T__23=23;
+    public static final int T__67=67;
+    public static final int T__24=24;
+    public static final int T__68=68;
+    public static final int T__25=25;
+    public static final int T__69=69;
+    public static final int T__62=62;
+    public static final int T__63=63;
+    public static final int T__20=20;
+    public static final int T__64=64;
+    public static final int T__21=21;
+    public static final int T__65=65;
+    public static final int T__70=70;
+    public static final int T__71=71;
+    public static final int T__72=72;
+    public static final int RULE_STRING=8;
+    public static final int RULE_SL_COMMENT=10;
+    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 T__33=33;
+    public static final int T__77=77;
+    public static final int T__34=34;
+    public static final int T__78=78;
+    public static final int T__35=35;
+    public static final int T__79=79;
+    public static final int T__36=36;
+    public static final int T__73=73;
+    public static final int EOF=-1;
+    public static final int T__30=30;
+    public static final int T__74=74;
+    public static final int T__31=31;
+    public static final int T__75=75;
+    public static final int T__32=32;
+    public static final int T__76=76;
+    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 RULE_WS=11;
+    public static final int RULE_ANY_OTHER=12;
+    public static final int T__48=48;
+    public static final int T__49=49;
+    public static final int T__44=44;
+    public static final int T__88=88;
+    public static final int T__45=45;
+    public static final int T__46=46;
+    public static final int T__47=47;
+    public static final int T__40=40;
+    public static final int T__84=84;
+    public static final int T__41=41;
+    public static final int T__85=85;
+    public static final int T__42=42;
+    public static final int T__86=86;
+    public static final int T__43=43;
+    public static final int T__87=87;
+
+    // delegates
+    // delegators
+
+
+        public InternalOXtypeParser(TokenStream input) {
+            this(input, new RecognizerSharedState());
+        }
+        public InternalOXtypeParser(TokenStream input, RecognizerSharedState state) {
+            super(input, state);
+             
+        }
+        
+
+    public String[] getTokenNames() { return InternalOXtypeParser.tokenNames; }
+    public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+
+    	private OXtypeGrammarAccess grammarAccess;
+
+    	public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+    		this.grammarAccess = grammarAccess;
+    	}
+
+    	@Override
+    	protected Grammar getGrammar() {
+    		return grammarAccess.getGrammar();
+    	}
+
+    	@Override
+    	protected String getValueForTokenName(String tokenName) {
+    		return tokenName;
+    	}
+
+
+
+    // $ANTLR start "entryRuleXImportDeclaration"
+    // InternalOXtype.g:54:1: entryRuleXImportDeclaration : ruleXImportDeclaration EOF ;
+    public final void entryRuleXImportDeclaration() throws RecognitionException {
+        try {
+            // InternalOXtype.g:55:1: ( ruleXImportDeclaration EOF )
+            // InternalOXtype.g:56:1: ruleXImportDeclaration EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXImportDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXImportDeclaration"
+
+
+    // $ANTLR start "ruleXImportDeclaration"
+    // InternalOXtype.g:63:1: ruleXImportDeclaration : ( ( rule__XImportDeclaration__Group__0 ) ) ;
+    public final void ruleXImportDeclaration() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:67:2: ( ( ( rule__XImportDeclaration__Group__0 ) ) )
+            // InternalOXtype.g:68:2: ( ( rule__XImportDeclaration__Group__0 ) )
+            {
+            // InternalOXtype.g:68:2: ( ( rule__XImportDeclaration__Group__0 ) )
+            // InternalOXtype.g:69:3: ( rule__XImportDeclaration__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getGroup()); 
+            }
+            // InternalOXtype.g:70:3: ( rule__XImportDeclaration__Group__0 )
+            // InternalOXtype.g:70:4: rule__XImportDeclaration__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXImportDeclaration"
+
+
+    // $ANTLR start "entryRuleXAnnotation"
+    // InternalOXtype.g:79:1: entryRuleXAnnotation : ruleXAnnotation EOF ;
+    public final void entryRuleXAnnotation() throws RecognitionException {
+        try {
+            // InternalOXtype.g:80:1: ( ruleXAnnotation EOF )
+            // InternalOXtype.g:81:1: ruleXAnnotation EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAnnotation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAnnotation"
+
+
+    // $ANTLR start "ruleXAnnotation"
+    // InternalOXtype.g:88:1: ruleXAnnotation : ( ( rule__XAnnotation__Group__0 ) ) ;
+    public final void ruleXAnnotation() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:92:2: ( ( ( rule__XAnnotation__Group__0 ) ) )
+            // InternalOXtype.g:93:2: ( ( rule__XAnnotation__Group__0 ) )
+            {
+            // InternalOXtype.g:93:2: ( ( rule__XAnnotation__Group__0 ) )
+            // InternalOXtype.g:94:3: ( rule__XAnnotation__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getGroup()); 
+            }
+            // InternalOXtype.g:95:3: ( rule__XAnnotation__Group__0 )
+            // InternalOXtype.g:95:4: rule__XAnnotation__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAnnotation"
+
+
+    // $ANTLR start "entryRuleXAnnotationElementValuePair"
+    // InternalOXtype.g:104:1: entryRuleXAnnotationElementValuePair : ruleXAnnotationElementValuePair EOF ;
+    public final void entryRuleXAnnotationElementValuePair() throws RecognitionException {
+        try {
+            // InternalOXtype.g:105:1: ( ruleXAnnotationElementValuePair EOF )
+            // InternalOXtype.g:106:1: ruleXAnnotationElementValuePair EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAnnotationElementValuePair();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAnnotationElementValuePair"
+
+
+    // $ANTLR start "ruleXAnnotationElementValuePair"
+    // InternalOXtype.g:113:1: ruleXAnnotationElementValuePair : ( ( rule__XAnnotationElementValuePair__Group__0 ) ) ;
+    public final void ruleXAnnotationElementValuePair() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:117:2: ( ( ( rule__XAnnotationElementValuePair__Group__0 ) ) )
+            // InternalOXtype.g:118:2: ( ( rule__XAnnotationElementValuePair__Group__0 ) )
+            {
+            // InternalOXtype.g:118:2: ( ( rule__XAnnotationElementValuePair__Group__0 ) )
+            // InternalOXtype.g:119:3: ( rule__XAnnotationElementValuePair__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); 
+            }
+            // InternalOXtype.g:120:3: ( rule__XAnnotationElementValuePair__Group__0 )
+            // InternalOXtype.g:120:4: rule__XAnnotationElementValuePair__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAnnotationElementValuePair"
+
+
+    // $ANTLR start "entryRuleXAnnotationElementValueOrCommaList"
+    // InternalOXtype.g:129:1: entryRuleXAnnotationElementValueOrCommaList : ruleXAnnotationElementValueOrCommaList EOF ;
+    public final void entryRuleXAnnotationElementValueOrCommaList() throws RecognitionException {
+        try {
+            // InternalOXtype.g:130:1: ( ruleXAnnotationElementValueOrCommaList EOF )
+            // InternalOXtype.g:131:1: ruleXAnnotationElementValueOrCommaList EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAnnotationElementValueOrCommaList();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAnnotationElementValueOrCommaList"
+
+
+    // $ANTLR start "ruleXAnnotationElementValueOrCommaList"
+    // InternalOXtype.g:138:1: ruleXAnnotationElementValueOrCommaList : ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) ;
+    public final void ruleXAnnotationElementValueOrCommaList() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:142:2: ( ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) ) )
+            // InternalOXtype.g:143:2: ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) )
+            {
+            // InternalOXtype.g:143:2: ( ( rule__XAnnotationElementValueOrCommaList__Alternatives ) )
+            // InternalOXtype.g:144:3: ( rule__XAnnotationElementValueOrCommaList__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:145:3: ( rule__XAnnotationElementValueOrCommaList__Alternatives )
+            // InternalOXtype.g:145:4: rule__XAnnotationElementValueOrCommaList__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAnnotationElementValueOrCommaList"
+
+
+    // $ANTLR start "entryRuleXAnnotationElementValue"
+    // InternalOXtype.g:154:1: entryRuleXAnnotationElementValue : ruleXAnnotationElementValue EOF ;
+    public final void entryRuleXAnnotationElementValue() throws RecognitionException {
+        try {
+            // InternalOXtype.g:155:1: ( ruleXAnnotationElementValue EOF )
+            // InternalOXtype.g:156:1: ruleXAnnotationElementValue EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAnnotationElementValue();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAnnotationElementValue"
+
+
+    // $ANTLR start "ruleXAnnotationElementValue"
+    // InternalOXtype.g:163:1: ruleXAnnotationElementValue : ( ( rule__XAnnotationElementValue__Alternatives ) ) ;
+    public final void ruleXAnnotationElementValue() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:167:2: ( ( ( rule__XAnnotationElementValue__Alternatives ) ) )
+            // InternalOXtype.g:168:2: ( ( rule__XAnnotationElementValue__Alternatives ) )
+            {
+            // InternalOXtype.g:168:2: ( ( rule__XAnnotationElementValue__Alternatives ) )
+            // InternalOXtype.g:169:3: ( rule__XAnnotationElementValue__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:170:3: ( rule__XAnnotationElementValue__Alternatives )
+            // InternalOXtype.g:170:4: rule__XAnnotationElementValue__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAnnotationElementValue"
+
+
+    // $ANTLR start "entryRuleXAnnotationOrExpression"
+    // InternalOXtype.g:179:1: entryRuleXAnnotationOrExpression : ruleXAnnotationOrExpression EOF ;
+    public final void entryRuleXAnnotationOrExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:180:1: ( ruleXAnnotationOrExpression EOF )
+            // InternalOXtype.g:181:1: ruleXAnnotationOrExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationOrExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationOrExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAnnotationOrExpression"
+
+
+    // $ANTLR start "ruleXAnnotationOrExpression"
+    // InternalOXtype.g:188:1: ruleXAnnotationOrExpression : ( ( rule__XAnnotationOrExpression__Alternatives ) ) ;
+    public final void ruleXAnnotationOrExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:192:2: ( ( ( rule__XAnnotationOrExpression__Alternatives ) ) )
+            // InternalOXtype.g:193:2: ( ( rule__XAnnotationOrExpression__Alternatives ) )
+            {
+            // InternalOXtype.g:193:2: ( ( rule__XAnnotationOrExpression__Alternatives ) )
+            // InternalOXtype.g:194:3: ( rule__XAnnotationOrExpression__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:195:3: ( rule__XAnnotationOrExpression__Alternatives )
+            // InternalOXtype.g:195:4: rule__XAnnotationOrExpression__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationOrExpression__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationOrExpressionAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAnnotationOrExpression"
+
+
+    // $ANTLR start "entryRuleXExpression"
+    // InternalOXtype.g:204:1: entryRuleXExpression : ruleXExpression EOF ;
+    public final void entryRuleXExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:205:1: ( ruleXExpression EOF )
+            // InternalOXtype.g:206:1: ruleXExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXExpression"
+
+
+    // $ANTLR start "ruleXExpression"
+    // InternalOXtype.g:213:1: ruleXExpression : ( ruleXAssignment ) ;
+    public final void ruleXExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:217:2: ( ( ruleXAssignment ) )
+            // InternalOXtype.g:218:2: ( ruleXAssignment )
+            {
+            // InternalOXtype.g:218:2: ( ruleXAssignment )
+            // InternalOXtype.g:219:3: ruleXAssignment
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXExpression"
+
+
+    // $ANTLR start "entryRuleXAssignment"
+    // InternalOXtype.g:229:1: entryRuleXAssignment : ruleXAssignment EOF ;
+    public final void entryRuleXAssignment() throws RecognitionException {
+        try {
+            // InternalOXtype.g:230:1: ( ruleXAssignment EOF )
+            // InternalOXtype.g:231:1: ruleXAssignment EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAssignment"
+
+
+    // $ANTLR start "ruleXAssignment"
+    // InternalOXtype.g:238:1: ruleXAssignment : ( ( rule__XAssignment__Alternatives ) ) ;
+    public final void ruleXAssignment() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:242:2: ( ( ( rule__XAssignment__Alternatives ) ) )
+            // InternalOXtype.g:243:2: ( ( rule__XAssignment__Alternatives ) )
+            {
+            // InternalOXtype.g:243:2: ( ( rule__XAssignment__Alternatives ) )
+            // InternalOXtype.g:244:3: ( rule__XAssignment__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:245:3: ( rule__XAssignment__Alternatives )
+            // InternalOXtype.g:245:4: rule__XAssignment__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAssignment"
+
+
+    // $ANTLR start "entryRuleOpSingleAssign"
+    // InternalOXtype.g:254:1: entryRuleOpSingleAssign : ruleOpSingleAssign EOF ;
+    public final void entryRuleOpSingleAssign() throws RecognitionException {
+        try {
+            // InternalOXtype.g:255:1: ( ruleOpSingleAssign EOF )
+            // InternalOXtype.g:256:1: ruleOpSingleAssign EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpSingleAssignRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpSingleAssign();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpSingleAssignRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpSingleAssign"
+
+
+    // $ANTLR start "ruleOpSingleAssign"
+    // InternalOXtype.g:263:1: ruleOpSingleAssign : ( '=' ) ;
+    public final void ruleOpSingleAssign() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:267:2: ( ( '=' ) )
+            // InternalOXtype.g:268:2: ( '=' )
+            {
+            // InternalOXtype.g:268:2: ( '=' )
+            // InternalOXtype.g:269:3: '='
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); 
+            }
+            match(input,13,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpSingleAssign"
+
+
+    // $ANTLR start "entryRuleOpMultiAssign"
+    // InternalOXtype.g:279:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ;
+    public final void entryRuleOpMultiAssign() throws RecognitionException {
+        try {
+            // InternalOXtype.g:280:1: ( ruleOpMultiAssign EOF )
+            // InternalOXtype.g:281:1: ruleOpMultiAssign EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpMultiAssign();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpMultiAssign"
+
+
+    // $ANTLR start "ruleOpMultiAssign"
+    // InternalOXtype.g:288:1: ruleOpMultiAssign : ( ( rule__OpMultiAssign__Alternatives ) ) ;
+    public final void ruleOpMultiAssign() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:292:2: ( ( ( rule__OpMultiAssign__Alternatives ) ) )
+            // InternalOXtype.g:293:2: ( ( rule__OpMultiAssign__Alternatives ) )
+            {
+            // InternalOXtype.g:293:2: ( ( rule__OpMultiAssign__Alternatives ) )
+            // InternalOXtype.g:294:3: ( rule__OpMultiAssign__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:295:3: ( rule__OpMultiAssign__Alternatives )
+            // InternalOXtype.g:295:4: rule__OpMultiAssign__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpMultiAssign"
+
+
+    // $ANTLR start "entryRuleXOrExpression"
+    // InternalOXtype.g:304:1: entryRuleXOrExpression : ruleXOrExpression EOF ;
+    public final void entryRuleXOrExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:305:1: ( ruleXOrExpression EOF )
+            // InternalOXtype.g:306:1: ruleXOrExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXOrExpression"
+
+
+    // $ANTLR start "ruleXOrExpression"
+    // InternalOXtype.g:313:1: ruleXOrExpression : ( ( rule__XOrExpression__Group__0 ) ) ;
+    public final void ruleXOrExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:317:2: ( ( ( rule__XOrExpression__Group__0 ) ) )
+            // InternalOXtype.g:318:2: ( ( rule__XOrExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:318:2: ( ( rule__XOrExpression__Group__0 ) )
+            // InternalOXtype.g:319:3: ( rule__XOrExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:320:3: ( rule__XOrExpression__Group__0 )
+            // InternalOXtype.g:320:4: rule__XOrExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXOrExpression"
+
+
+    // $ANTLR start "entryRuleOpOr"
+    // InternalOXtype.g:329:1: entryRuleOpOr : ruleOpOr EOF ;
+    public final void entryRuleOpOr() throws RecognitionException {
+        try {
+            // InternalOXtype.g:330:1: ( ruleOpOr EOF )
+            // InternalOXtype.g:331:1: ruleOpOr EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOrRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpOr();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOrRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpOr"
+
+
+    // $ANTLR start "ruleOpOr"
+    // InternalOXtype.g:338:1: ruleOpOr : ( '||' ) ;
+    public final void ruleOpOr() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:342:2: ( ( '||' ) )
+            // InternalOXtype.g:343:2: ( '||' )
+            {
+            // InternalOXtype.g:343:2: ( '||' )
+            // InternalOXtype.g:344:3: '||'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); 
+            }
+            match(input,14,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpOr"
+
+
+    // $ANTLR start "entryRuleXAndExpression"
+    // InternalOXtype.g:354:1: entryRuleXAndExpression : ruleXAndExpression EOF ;
+    public final void entryRuleXAndExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:355:1: ( ruleXAndExpression EOF )
+            // InternalOXtype.g:356:1: ruleXAndExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAndExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAndExpression"
+
+
+    // $ANTLR start "ruleXAndExpression"
+    // InternalOXtype.g:363:1: ruleXAndExpression : ( ( rule__XAndExpression__Group__0 ) ) ;
+    public final void ruleXAndExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:367:2: ( ( ( rule__XAndExpression__Group__0 ) ) )
+            // InternalOXtype.g:368:2: ( ( rule__XAndExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:368:2: ( ( rule__XAndExpression__Group__0 ) )
+            // InternalOXtype.g:369:3: ( rule__XAndExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:370:3: ( rule__XAndExpression__Group__0 )
+            // InternalOXtype.g:370:4: rule__XAndExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAndExpression"
+
+
+    // $ANTLR start "entryRuleOpAnd"
+    // InternalOXtype.g:379:1: entryRuleOpAnd : ruleOpAnd EOF ;
+    public final void entryRuleOpAnd() throws RecognitionException {
+        try {
+            // InternalOXtype.g:380:1: ( ruleOpAnd EOF )
+            // InternalOXtype.g:381:1: ruleOpAnd EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpAndRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpAnd();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpAndRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpAnd"
+
+
+    // $ANTLR start "ruleOpAnd"
+    // InternalOXtype.g:388:1: ruleOpAnd : ( '&&' ) ;
+    public final void ruleOpAnd() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:392:2: ( ( '&&' ) )
+            // InternalOXtype.g:393:2: ( '&&' )
+            {
+            // InternalOXtype.g:393:2: ( '&&' )
+            // InternalOXtype.g:394:3: '&&'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); 
+            }
+            match(input,15,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpAnd"
+
+
+    // $ANTLR start "entryRuleXEqualityExpression"
+    // InternalOXtype.g:404:1: entryRuleXEqualityExpression : ruleXEqualityExpression EOF ;
+    public final void entryRuleXEqualityExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:405:1: ( ruleXEqualityExpression EOF )
+            // InternalOXtype.g:406:1: ruleXEqualityExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXEqualityExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXEqualityExpression"
+
+
+    // $ANTLR start "ruleXEqualityExpression"
+    // InternalOXtype.g:413:1: ruleXEqualityExpression : ( ( rule__XEqualityExpression__Group__0 ) ) ;
+    public final void ruleXEqualityExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:417:2: ( ( ( rule__XEqualityExpression__Group__0 ) ) )
+            // InternalOXtype.g:418:2: ( ( rule__XEqualityExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:418:2: ( ( rule__XEqualityExpression__Group__0 ) )
+            // InternalOXtype.g:419:3: ( rule__XEqualityExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:420:3: ( rule__XEqualityExpression__Group__0 )
+            // InternalOXtype.g:420:4: rule__XEqualityExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXEqualityExpression"
+
+
+    // $ANTLR start "entryRuleOpEquality"
+    // InternalOXtype.g:429:1: entryRuleOpEquality : ruleOpEquality EOF ;
+    public final void entryRuleOpEquality() throws RecognitionException {
+        try {
+            // InternalOXtype.g:430:1: ( ruleOpEquality EOF )
+            // InternalOXtype.g:431:1: ruleOpEquality EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpEqualityRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpEquality();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpEqualityRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpEquality"
+
+
+    // $ANTLR start "ruleOpEquality"
+    // InternalOXtype.g:438:1: ruleOpEquality : ( ( rule__OpEquality__Alternatives ) ) ;
+    public final void ruleOpEquality() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:442:2: ( ( ( rule__OpEquality__Alternatives ) ) )
+            // InternalOXtype.g:443:2: ( ( rule__OpEquality__Alternatives ) )
+            {
+            // InternalOXtype.g:443:2: ( ( rule__OpEquality__Alternatives ) )
+            // InternalOXtype.g:444:3: ( rule__OpEquality__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpEqualityAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:445:3: ( rule__OpEquality__Alternatives )
+            // InternalOXtype.g:445:4: rule__OpEquality__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpEquality__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpEqualityAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpEquality"
+
+
+    // $ANTLR start "entryRuleXRelationalExpression"
+    // InternalOXtype.g:454:1: entryRuleXRelationalExpression : ruleXRelationalExpression EOF ;
+    public final void entryRuleXRelationalExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:455:1: ( ruleXRelationalExpression EOF )
+            // InternalOXtype.g:456:1: ruleXRelationalExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXRelationalExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXRelationalExpression"
+
+
+    // $ANTLR start "ruleXRelationalExpression"
+    // InternalOXtype.g:463:1: ruleXRelationalExpression : ( ( rule__XRelationalExpression__Group__0 ) ) ;
+    public final void ruleXRelationalExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:467:2: ( ( ( rule__XRelationalExpression__Group__0 ) ) )
+            // InternalOXtype.g:468:2: ( ( rule__XRelationalExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:468:2: ( ( rule__XRelationalExpression__Group__0 ) )
+            // InternalOXtype.g:469:3: ( rule__XRelationalExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:470:3: ( rule__XRelationalExpression__Group__0 )
+            // InternalOXtype.g:470:4: rule__XRelationalExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXRelationalExpression"
+
+
+    // $ANTLR start "entryRuleOpCompare"
+    // InternalOXtype.g:479:1: entryRuleOpCompare : ruleOpCompare EOF ;
+    public final void entryRuleOpCompare() throws RecognitionException {
+        try {
+            // InternalOXtype.g:480:1: ( ruleOpCompare EOF )
+            // InternalOXtype.g:481:1: ruleOpCompare EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpCompareRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpCompare();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpCompareRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpCompare"
+
+
+    // $ANTLR start "ruleOpCompare"
+    // InternalOXtype.g:488:1: ruleOpCompare : ( ( rule__OpCompare__Alternatives ) ) ;
+    public final void ruleOpCompare() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:492:2: ( ( ( rule__OpCompare__Alternatives ) ) )
+            // InternalOXtype.g:493:2: ( ( rule__OpCompare__Alternatives ) )
+            {
+            // InternalOXtype.g:493:2: ( ( rule__OpCompare__Alternatives ) )
+            // InternalOXtype.g:494:3: ( rule__OpCompare__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpCompareAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:495:3: ( rule__OpCompare__Alternatives )
+            // InternalOXtype.g:495:4: rule__OpCompare__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpCompare__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpCompareAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpCompare"
+
+
+    // $ANTLR start "entryRuleXOtherOperatorExpression"
+    // InternalOXtype.g:504:1: entryRuleXOtherOperatorExpression : ruleXOtherOperatorExpression EOF ;
+    public final void entryRuleXOtherOperatorExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:505:1: ( ruleXOtherOperatorExpression EOF )
+            // InternalOXtype.g:506:1: ruleXOtherOperatorExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXOtherOperatorExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXOtherOperatorExpression"
+
+
+    // $ANTLR start "ruleXOtherOperatorExpression"
+    // InternalOXtype.g:513:1: ruleXOtherOperatorExpression : ( ( rule__XOtherOperatorExpression__Group__0 ) ) ;
+    public final void ruleXOtherOperatorExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:517:2: ( ( ( rule__XOtherOperatorExpression__Group__0 ) ) )
+            // InternalOXtype.g:518:2: ( ( rule__XOtherOperatorExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:518:2: ( ( rule__XOtherOperatorExpression__Group__0 ) )
+            // InternalOXtype.g:519:3: ( rule__XOtherOperatorExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:520:3: ( rule__XOtherOperatorExpression__Group__0 )
+            // InternalOXtype.g:520:4: rule__XOtherOperatorExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXOtherOperatorExpression"
+
+
+    // $ANTLR start "entryRuleOpOther"
+    // InternalOXtype.g:529:1: entryRuleOpOther : ruleOpOther EOF ;
+    public final void entryRuleOpOther() throws RecognitionException {
+        try {
+            // InternalOXtype.g:530:1: ( ruleOpOther EOF )
+            // InternalOXtype.g:531:1: ruleOpOther EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpOther();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpOther"
+
+
+    // $ANTLR start "ruleOpOther"
+    // InternalOXtype.g:538:1: ruleOpOther : ( ( rule__OpOther__Alternatives ) ) ;
+    public final void ruleOpOther() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:542:2: ( ( ( rule__OpOther__Alternatives ) ) )
+            // InternalOXtype.g:543:2: ( ( rule__OpOther__Alternatives ) )
+            {
+            // InternalOXtype.g:543:2: ( ( rule__OpOther__Alternatives ) )
+            // InternalOXtype.g:544:3: ( rule__OpOther__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:545:3: ( rule__OpOther__Alternatives )
+            // InternalOXtype.g:545:4: rule__OpOther__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpOther"
+
+
+    // $ANTLR start "entryRuleXAdditiveExpression"
+    // InternalOXtype.g:554:1: entryRuleXAdditiveExpression : ruleXAdditiveExpression EOF ;
+    public final void entryRuleXAdditiveExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:555:1: ( ruleXAdditiveExpression EOF )
+            // InternalOXtype.g:556:1: ruleXAdditiveExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXAdditiveExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXAdditiveExpression"
+
+
+    // $ANTLR start "ruleXAdditiveExpression"
+    // InternalOXtype.g:563:1: ruleXAdditiveExpression : ( ( rule__XAdditiveExpression__Group__0 ) ) ;
+    public final void ruleXAdditiveExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:567:2: ( ( ( rule__XAdditiveExpression__Group__0 ) ) )
+            // InternalOXtype.g:568:2: ( ( rule__XAdditiveExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:568:2: ( ( rule__XAdditiveExpression__Group__0 ) )
+            // InternalOXtype.g:569:3: ( rule__XAdditiveExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:570:3: ( rule__XAdditiveExpression__Group__0 )
+            // InternalOXtype.g:570:4: rule__XAdditiveExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXAdditiveExpression"
+
+
+    // $ANTLR start "entryRuleOpAdd"
+    // InternalOXtype.g:579:1: entryRuleOpAdd : ruleOpAdd EOF ;
+    public final void entryRuleOpAdd() throws RecognitionException {
+        try {
+            // InternalOXtype.g:580:1: ( ruleOpAdd EOF )
+            // InternalOXtype.g:581:1: ruleOpAdd EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpAddRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpAdd();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpAddRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpAdd"
+
+
+    // $ANTLR start "ruleOpAdd"
+    // InternalOXtype.g:588:1: ruleOpAdd : ( ( rule__OpAdd__Alternatives ) ) ;
+    public final void ruleOpAdd() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:592:2: ( ( ( rule__OpAdd__Alternatives ) ) )
+            // InternalOXtype.g:593:2: ( ( rule__OpAdd__Alternatives ) )
+            {
+            // InternalOXtype.g:593:2: ( ( rule__OpAdd__Alternatives ) )
+            // InternalOXtype.g:594:3: ( rule__OpAdd__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpAddAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:595:3: ( rule__OpAdd__Alternatives )
+            // InternalOXtype.g:595:4: rule__OpAdd__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpAdd__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpAddAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpAdd"
+
+
+    // $ANTLR start "entryRuleXMultiplicativeExpression"
+    // InternalOXtype.g:604:1: entryRuleXMultiplicativeExpression : ruleXMultiplicativeExpression EOF ;
+    public final void entryRuleXMultiplicativeExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:605:1: ( ruleXMultiplicativeExpression EOF )
+            // InternalOXtype.g:606:1: ruleXMultiplicativeExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXMultiplicativeExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXMultiplicativeExpression"
+
+
+    // $ANTLR start "ruleXMultiplicativeExpression"
+    // InternalOXtype.g:613:1: ruleXMultiplicativeExpression : ( ( rule__XMultiplicativeExpression__Group__0 ) ) ;
+    public final void ruleXMultiplicativeExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:617:2: ( ( ( rule__XMultiplicativeExpression__Group__0 ) ) )
+            // InternalOXtype.g:618:2: ( ( rule__XMultiplicativeExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:618:2: ( ( rule__XMultiplicativeExpression__Group__0 ) )
+            // InternalOXtype.g:619:3: ( rule__XMultiplicativeExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:620:3: ( rule__XMultiplicativeExpression__Group__0 )
+            // InternalOXtype.g:620:4: rule__XMultiplicativeExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXMultiplicativeExpression"
+
+
+    // $ANTLR start "entryRuleOpMulti"
+    // InternalOXtype.g:629:1: entryRuleOpMulti : ruleOpMulti EOF ;
+    public final void entryRuleOpMulti() throws RecognitionException {
+        try {
+            // InternalOXtype.g:630:1: ( ruleOpMulti EOF )
+            // InternalOXtype.g:631:1: ruleOpMulti EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpMulti();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpMulti"
+
+
+    // $ANTLR start "ruleOpMulti"
+    // InternalOXtype.g:638:1: ruleOpMulti : ( ( rule__OpMulti__Alternatives ) ) ;
+    public final void ruleOpMulti() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:642:2: ( ( ( rule__OpMulti__Alternatives ) ) )
+            // InternalOXtype.g:643:2: ( ( rule__OpMulti__Alternatives ) )
+            {
+            // InternalOXtype.g:643:2: ( ( rule__OpMulti__Alternatives ) )
+            // InternalOXtype.g:644:3: ( rule__OpMulti__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:645:3: ( rule__OpMulti__Alternatives )
+            // InternalOXtype.g:645:4: rule__OpMulti__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpMulti__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpMulti"
+
+
+    // $ANTLR start "entryRuleXUnaryOperation"
+    // InternalOXtype.g:654:1: entryRuleXUnaryOperation : ruleXUnaryOperation EOF ;
+    public final void entryRuleXUnaryOperation() throws RecognitionException {
+        try {
+            // InternalOXtype.g:655:1: ( ruleXUnaryOperation EOF )
+            // InternalOXtype.g:656:1: ruleXUnaryOperation EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXUnaryOperation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXUnaryOperation"
+
+
+    // $ANTLR start "ruleXUnaryOperation"
+    // InternalOXtype.g:663:1: ruleXUnaryOperation : ( ( rule__XUnaryOperation__Alternatives ) ) ;
+    public final void ruleXUnaryOperation() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:667:2: ( ( ( rule__XUnaryOperation__Alternatives ) ) )
+            // InternalOXtype.g:668:2: ( ( rule__XUnaryOperation__Alternatives ) )
+            {
+            // InternalOXtype.g:668:2: ( ( rule__XUnaryOperation__Alternatives ) )
+            // InternalOXtype.g:669:3: ( rule__XUnaryOperation__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:670:3: ( rule__XUnaryOperation__Alternatives )
+            // InternalOXtype.g:670:4: rule__XUnaryOperation__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XUnaryOperation__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXUnaryOperation"
+
+
+    // $ANTLR start "entryRuleOpUnary"
+    // InternalOXtype.g:679:1: entryRuleOpUnary : ruleOpUnary EOF ;
+    public final void entryRuleOpUnary() throws RecognitionException {
+        try {
+            // InternalOXtype.g:680:1: ( ruleOpUnary EOF )
+            // InternalOXtype.g:681:1: ruleOpUnary EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpUnaryRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpUnary();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpUnaryRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpUnary"
+
+
+    // $ANTLR start "ruleOpUnary"
+    // InternalOXtype.g:688:1: ruleOpUnary : ( ( rule__OpUnary__Alternatives ) ) ;
+    public final void ruleOpUnary() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:692:2: ( ( ( rule__OpUnary__Alternatives ) ) )
+            // InternalOXtype.g:693:2: ( ( rule__OpUnary__Alternatives ) )
+            {
+            // InternalOXtype.g:693:2: ( ( rule__OpUnary__Alternatives ) )
+            // InternalOXtype.g:694:3: ( rule__OpUnary__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpUnaryAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:695:3: ( rule__OpUnary__Alternatives )
+            // InternalOXtype.g:695:4: rule__OpUnary__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpUnary__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpUnaryAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpUnary"
+
+
+    // $ANTLR start "entryRuleXCastedExpression"
+    // InternalOXtype.g:704:1: entryRuleXCastedExpression : ruleXCastedExpression EOF ;
+    public final void entryRuleXCastedExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:705:1: ( ruleXCastedExpression EOF )
+            // InternalOXtype.g:706:1: ruleXCastedExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXCastedExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXCastedExpression"
+
+
+    // $ANTLR start "ruleXCastedExpression"
+    // InternalOXtype.g:713:1: ruleXCastedExpression : ( ( rule__XCastedExpression__Group__0 ) ) ;
+    public final void ruleXCastedExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:717:2: ( ( ( rule__XCastedExpression__Group__0 ) ) )
+            // InternalOXtype.g:718:2: ( ( rule__XCastedExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:718:2: ( ( rule__XCastedExpression__Group__0 ) )
+            // InternalOXtype.g:719:3: ( rule__XCastedExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:720:3: ( rule__XCastedExpression__Group__0 )
+            // InternalOXtype.g:720:4: rule__XCastedExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXCastedExpression"
+
+
+    // $ANTLR start "entryRuleXPostfixOperation"
+    // InternalOXtype.g:729:1: entryRuleXPostfixOperation : ruleXPostfixOperation EOF ;
+    public final void entryRuleXPostfixOperation() throws RecognitionException {
+        try {
+            // InternalOXtype.g:730:1: ( ruleXPostfixOperation EOF )
+            // InternalOXtype.g:731:1: ruleXPostfixOperation EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXPostfixOperation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXPostfixOperation"
+
+
+    // $ANTLR start "ruleXPostfixOperation"
+    // InternalOXtype.g:738:1: ruleXPostfixOperation : ( ( rule__XPostfixOperation__Group__0 ) ) ;
+    public final void ruleXPostfixOperation() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:742:2: ( ( ( rule__XPostfixOperation__Group__0 ) ) )
+            // InternalOXtype.g:743:2: ( ( rule__XPostfixOperation__Group__0 ) )
+            {
+            // InternalOXtype.g:743:2: ( ( rule__XPostfixOperation__Group__0 ) )
+            // InternalOXtype.g:744:3: ( rule__XPostfixOperation__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getGroup()); 
+            }
+            // InternalOXtype.g:745:3: ( rule__XPostfixOperation__Group__0 )
+            // InternalOXtype.g:745:4: rule__XPostfixOperation__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXPostfixOperation"
+
+
+    // $ANTLR start "entryRuleOpPostfix"
+    // InternalOXtype.g:754:1: entryRuleOpPostfix : ruleOpPostfix EOF ;
+    public final void entryRuleOpPostfix() throws RecognitionException {
+        try {
+            // InternalOXtype.g:755:1: ( ruleOpPostfix EOF )
+            // InternalOXtype.g:756:1: ruleOpPostfix EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpPostfixRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleOpPostfix();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpPostfixRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleOpPostfix"
+
+
+    // $ANTLR start "ruleOpPostfix"
+    // InternalOXtype.g:763:1: ruleOpPostfix : ( ( rule__OpPostfix__Alternatives ) ) ;
+    public final void ruleOpPostfix() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:767:2: ( ( ( rule__OpPostfix__Alternatives ) ) )
+            // InternalOXtype.g:768:2: ( ( rule__OpPostfix__Alternatives ) )
+            {
+            // InternalOXtype.g:768:2: ( ( rule__OpPostfix__Alternatives ) )
+            // InternalOXtype.g:769:3: ( rule__OpPostfix__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpPostfixAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:770:3: ( rule__OpPostfix__Alternatives )
+            // InternalOXtype.g:770:4: rule__OpPostfix__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpPostfix__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpPostfixAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleOpPostfix"
+
+
+    // $ANTLR start "entryRuleXMemberFeatureCall"
+    // InternalOXtype.g:779:1: entryRuleXMemberFeatureCall : ruleXMemberFeatureCall EOF ;
+    public final void entryRuleXMemberFeatureCall() throws RecognitionException {
+        try {
+            // InternalOXtype.g:780:1: ( ruleXMemberFeatureCall EOF )
+            // InternalOXtype.g:781:1: ruleXMemberFeatureCall EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXMemberFeatureCall();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXMemberFeatureCall"
+
+
+    // $ANTLR start "ruleXMemberFeatureCall"
+    // InternalOXtype.g:788:1: ruleXMemberFeatureCall : ( ( rule__XMemberFeatureCall__Group__0 ) ) ;
+    public final void ruleXMemberFeatureCall() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:792:2: ( ( ( rule__XMemberFeatureCall__Group__0 ) ) )
+            // InternalOXtype.g:793:2: ( ( rule__XMemberFeatureCall__Group__0 ) )
+            {
+            // InternalOXtype.g:793:2: ( ( rule__XMemberFeatureCall__Group__0 ) )
+            // InternalOXtype.g:794:3: ( rule__XMemberFeatureCall__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); 
+            }
+            // InternalOXtype.g:795:3: ( rule__XMemberFeatureCall__Group__0 )
+            // InternalOXtype.g:795:4: rule__XMemberFeatureCall__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXMemberFeatureCall"
+
+
+    // $ANTLR start "entryRuleXPrimaryExpression"
+    // InternalOXtype.g:804:1: entryRuleXPrimaryExpression : ruleXPrimaryExpression EOF ;
+    public final void entryRuleXPrimaryExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:805:1: ( ruleXPrimaryExpression EOF )
+            // InternalOXtype.g:806:1: ruleXPrimaryExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPrimaryExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXPrimaryExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPrimaryExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXPrimaryExpression"
+
+
+    // $ANTLR start "ruleXPrimaryExpression"
+    // InternalOXtype.g:813:1: ruleXPrimaryExpression : ( ( rule__XPrimaryExpression__Alternatives ) ) ;
+    public final void ruleXPrimaryExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:817:2: ( ( ( rule__XPrimaryExpression__Alternatives ) ) )
+            // InternalOXtype.g:818:2: ( ( rule__XPrimaryExpression__Alternatives ) )
+            {
+            // InternalOXtype.g:818:2: ( ( rule__XPrimaryExpression__Alternatives ) )
+            // InternalOXtype.g:819:3: ( rule__XPrimaryExpression__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:820:3: ( rule__XPrimaryExpression__Alternatives )
+            // InternalOXtype.g:820:4: rule__XPrimaryExpression__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPrimaryExpression__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXPrimaryExpression"
+
+
+    // $ANTLR start "entryRuleXLiteral"
+    // InternalOXtype.g:829:1: entryRuleXLiteral : ruleXLiteral EOF ;
+    public final void entryRuleXLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:830:1: ( ruleXLiteral EOF )
+            // InternalOXtype.g:831:1: ruleXLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXLiteral"
+
+
+    // $ANTLR start "ruleXLiteral"
+    // InternalOXtype.g:838:1: ruleXLiteral : ( ( rule__XLiteral__Alternatives ) ) ;
+    public final void ruleXLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:842:2: ( ( ( rule__XLiteral__Alternatives ) ) )
+            // InternalOXtype.g:843:2: ( ( rule__XLiteral__Alternatives ) )
+            {
+            // InternalOXtype.g:843:2: ( ( rule__XLiteral__Alternatives ) )
+            // InternalOXtype.g:844:3: ( rule__XLiteral__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXLiteralAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:845:3: ( rule__XLiteral__Alternatives )
+            // InternalOXtype.g:845:4: rule__XLiteral__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XLiteral__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXLiteralAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXLiteral"
+
+
+    // $ANTLR start "entryRuleXCollectionLiteral"
+    // InternalOXtype.g:854:1: entryRuleXCollectionLiteral : ruleXCollectionLiteral EOF ;
+    public final void entryRuleXCollectionLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:855:1: ( ruleXCollectionLiteral EOF )
+            // InternalOXtype.g:856:1: ruleXCollectionLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCollectionLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXCollectionLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCollectionLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXCollectionLiteral"
+
+
+    // $ANTLR start "ruleXCollectionLiteral"
+    // InternalOXtype.g:863:1: ruleXCollectionLiteral : ( ( rule__XCollectionLiteral__Alternatives ) ) ;
+    public final void ruleXCollectionLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:867:2: ( ( ( rule__XCollectionLiteral__Alternatives ) ) )
+            // InternalOXtype.g:868:2: ( ( rule__XCollectionLiteral__Alternatives ) )
+            {
+            // InternalOXtype.g:868:2: ( ( rule__XCollectionLiteral__Alternatives ) )
+            // InternalOXtype.g:869:3: ( rule__XCollectionLiteral__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:870:3: ( rule__XCollectionLiteral__Alternatives )
+            // InternalOXtype.g:870:4: rule__XCollectionLiteral__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCollectionLiteral__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXCollectionLiteral"
+
+
+    // $ANTLR start "entryRuleXSetLiteral"
+    // InternalOXtype.g:879:1: entryRuleXSetLiteral : ruleXSetLiteral EOF ;
+    public final void entryRuleXSetLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:880:1: ( ruleXSetLiteral EOF )
+            // InternalOXtype.g:881:1: ruleXSetLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXSetLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXSetLiteral"
+
+
+    // $ANTLR start "ruleXSetLiteral"
+    // InternalOXtype.g:888:1: ruleXSetLiteral : ( ( rule__XSetLiteral__Group__0 ) ) ;
+    public final void ruleXSetLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:892:2: ( ( ( rule__XSetLiteral__Group__0 ) ) )
+            // InternalOXtype.g:893:2: ( ( rule__XSetLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:893:2: ( ( rule__XSetLiteral__Group__0 ) )
+            // InternalOXtype.g:894:3: ( rule__XSetLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:895:3: ( rule__XSetLiteral__Group__0 )
+            // InternalOXtype.g:895:4: rule__XSetLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXSetLiteral"
+
+
+    // $ANTLR start "entryRuleXListLiteral"
+    // InternalOXtype.g:904:1: entryRuleXListLiteral : ruleXListLiteral EOF ;
+    public final void entryRuleXListLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:905:1: ( ruleXListLiteral EOF )
+            // InternalOXtype.g:906:1: ruleXListLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXListLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXListLiteral"
+
+
+    // $ANTLR start "ruleXListLiteral"
+    // InternalOXtype.g:913:1: ruleXListLiteral : ( ( rule__XListLiteral__Group__0 ) ) ;
+    public final void ruleXListLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:917:2: ( ( ( rule__XListLiteral__Group__0 ) ) )
+            // InternalOXtype.g:918:2: ( ( rule__XListLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:918:2: ( ( rule__XListLiteral__Group__0 ) )
+            // InternalOXtype.g:919:3: ( rule__XListLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:920:3: ( rule__XListLiteral__Group__0 )
+            // InternalOXtype.g:920:4: rule__XListLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXListLiteral"
+
+
+    // $ANTLR start "entryRuleXClosure"
+    // InternalOXtype.g:929:1: entryRuleXClosure : ruleXClosure EOF ;
+    public final void entryRuleXClosure() throws RecognitionException {
+        try {
+            // InternalOXtype.g:930:1: ( ruleXClosure EOF )
+            // InternalOXtype.g:931:1: ruleXClosure EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXClosure"
+
+
+    // $ANTLR start "ruleXClosure"
+    // InternalOXtype.g:938:1: ruleXClosure : ( ( rule__XClosure__Group__0 ) ) ;
+    public final void ruleXClosure() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:942:2: ( ( ( rule__XClosure__Group__0 ) ) )
+            // InternalOXtype.g:943:2: ( ( rule__XClosure__Group__0 ) )
+            {
+            // InternalOXtype.g:943:2: ( ( rule__XClosure__Group__0 ) )
+            // InternalOXtype.g:944:3: ( rule__XClosure__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup()); 
+            }
+            // InternalOXtype.g:945:3: ( rule__XClosure__Group__0 )
+            // InternalOXtype.g:945:4: rule__XClosure__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXClosure"
+
+
+    // $ANTLR start "entryRuleXExpressionInClosure"
+    // InternalOXtype.g:954:1: entryRuleXExpressionInClosure : ruleXExpressionInClosure EOF ;
+    public final void entryRuleXExpressionInClosure() throws RecognitionException {
+        try {
+            // InternalOXtype.g:955:1: ( ruleXExpressionInClosure EOF )
+            // InternalOXtype.g:956:1: ruleXExpressionInClosure EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXExpressionInClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXExpressionInClosure"
+
+
+    // $ANTLR start "ruleXExpressionInClosure"
+    // InternalOXtype.g:963:1: ruleXExpressionInClosure : ( ( rule__XExpressionInClosure__Group__0 ) ) ;
+    public final void ruleXExpressionInClosure() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:967:2: ( ( ( rule__XExpressionInClosure__Group__0 ) ) )
+            // InternalOXtype.g:968:2: ( ( rule__XExpressionInClosure__Group__0 ) )
+            {
+            // InternalOXtype.g:968:2: ( ( rule__XExpressionInClosure__Group__0 ) )
+            // InternalOXtype.g:969:3: ( rule__XExpressionInClosure__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureAccess().getGroup()); 
+            }
+            // InternalOXtype.g:970:3: ( rule__XExpressionInClosure__Group__0 )
+            // InternalOXtype.g:970:4: rule__XExpressionInClosure__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XExpressionInClosure__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXExpressionInClosure"
+
+
+    // $ANTLR start "entryRuleXShortClosure"
+    // InternalOXtype.g:979:1: entryRuleXShortClosure : ruleXShortClosure EOF ;
+    public final void entryRuleXShortClosure() throws RecognitionException {
+        try {
+            // InternalOXtype.g:980:1: ( ruleXShortClosure EOF )
+            // InternalOXtype.g:981:1: ruleXShortClosure EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXShortClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXShortClosure"
+
+
+    // $ANTLR start "ruleXShortClosure"
+    // InternalOXtype.g:988:1: ruleXShortClosure : ( ( rule__XShortClosure__Group__0 ) ) ;
+    public final void ruleXShortClosure() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:992:2: ( ( ( rule__XShortClosure__Group__0 ) ) )
+            // InternalOXtype.g:993:2: ( ( rule__XShortClosure__Group__0 ) )
+            {
+            // InternalOXtype.g:993:2: ( ( rule__XShortClosure__Group__0 ) )
+            // InternalOXtype.g:994:3: ( rule__XShortClosure__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getGroup()); 
+            }
+            // InternalOXtype.g:995:3: ( rule__XShortClosure__Group__0 )
+            // InternalOXtype.g:995:4: rule__XShortClosure__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXShortClosure"
+
+
+    // $ANTLR start "entryRuleXParenthesizedExpression"
+    // InternalOXtype.g:1004:1: entryRuleXParenthesizedExpression : ruleXParenthesizedExpression EOF ;
+    public final void entryRuleXParenthesizedExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1005:1: ( ruleXParenthesizedExpression EOF )
+            // InternalOXtype.g:1006:1: ruleXParenthesizedExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXParenthesizedExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXParenthesizedExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXParenthesizedExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXParenthesizedExpression"
+
+
+    // $ANTLR start "ruleXParenthesizedExpression"
+    // InternalOXtype.g:1013:1: ruleXParenthesizedExpression : ( ( rule__XParenthesizedExpression__Group__0 ) ) ;
+    public final void ruleXParenthesizedExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1017:2: ( ( ( rule__XParenthesizedExpression__Group__0 ) ) )
+            // InternalOXtype.g:1018:2: ( ( rule__XParenthesizedExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1018:2: ( ( rule__XParenthesizedExpression__Group__0 ) )
+            // InternalOXtype.g:1019:3: ( rule__XParenthesizedExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1020:3: ( rule__XParenthesizedExpression__Group__0 )
+            // InternalOXtype.g:1020:4: rule__XParenthesizedExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XParenthesizedExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXParenthesizedExpression"
+
+
+    // $ANTLR start "entryRuleXIfExpression"
+    // InternalOXtype.g:1029:1: entryRuleXIfExpression : ruleXIfExpression EOF ;
+    public final void entryRuleXIfExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1030:1: ( ruleXIfExpression EOF )
+            // InternalOXtype.g:1031:1: ruleXIfExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXIfExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXIfExpression"
+
+
+    // $ANTLR start "ruleXIfExpression"
+    // InternalOXtype.g:1038:1: ruleXIfExpression : ( ( rule__XIfExpression__Group__0 ) ) ;
+    public final void ruleXIfExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1042:2: ( ( ( rule__XIfExpression__Group__0 ) ) )
+            // InternalOXtype.g:1043:2: ( ( rule__XIfExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1043:2: ( ( rule__XIfExpression__Group__0 ) )
+            // InternalOXtype.g:1044:3: ( rule__XIfExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1045:3: ( rule__XIfExpression__Group__0 )
+            // InternalOXtype.g:1045:4: rule__XIfExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXIfExpression"
+
+
+    // $ANTLR start "entryRuleXSwitchExpression"
+    // InternalOXtype.g:1054:1: entryRuleXSwitchExpression : ruleXSwitchExpression EOF ;
+    public final void entryRuleXSwitchExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1055:1: ( ruleXSwitchExpression EOF )
+            // InternalOXtype.g:1056:1: ruleXSwitchExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXSwitchExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXSwitchExpression"
+
+
+    // $ANTLR start "ruleXSwitchExpression"
+    // InternalOXtype.g:1063:1: ruleXSwitchExpression : ( ( rule__XSwitchExpression__Group__0 ) ) ;
+    public final void ruleXSwitchExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1067:2: ( ( ( rule__XSwitchExpression__Group__0 ) ) )
+            // InternalOXtype.g:1068:2: ( ( rule__XSwitchExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1068:2: ( ( rule__XSwitchExpression__Group__0 ) )
+            // InternalOXtype.g:1069:3: ( rule__XSwitchExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1070:3: ( rule__XSwitchExpression__Group__0 )
+            // InternalOXtype.g:1070:4: rule__XSwitchExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXSwitchExpression"
+
+
+    // $ANTLR start "entryRuleXCasePart"
+    // InternalOXtype.g:1079:1: entryRuleXCasePart : ruleXCasePart EOF ;
+    public final void entryRuleXCasePart() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1080:1: ( ruleXCasePart EOF )
+            // InternalOXtype.g:1081:1: ruleXCasePart EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXCasePart();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXCasePart"
+
+
+    // $ANTLR start "ruleXCasePart"
+    // InternalOXtype.g:1088:1: ruleXCasePart : ( ( rule__XCasePart__Group__0 ) ) ;
+    public final void ruleXCasePart() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1092:2: ( ( ( rule__XCasePart__Group__0 ) ) )
+            // InternalOXtype.g:1093:2: ( ( rule__XCasePart__Group__0 ) )
+            {
+            // InternalOXtype.g:1093:2: ( ( rule__XCasePart__Group__0 ) )
+            // InternalOXtype.g:1094:3: ( rule__XCasePart__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1095:3: ( rule__XCasePart__Group__0 )
+            // InternalOXtype.g:1095:4: rule__XCasePart__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXCasePart"
+
+
+    // $ANTLR start "entryRuleXForLoopExpression"
+    // InternalOXtype.g:1104:1: entryRuleXForLoopExpression : ruleXForLoopExpression EOF ;
+    public final void entryRuleXForLoopExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1105:1: ( ruleXForLoopExpression EOF )
+            // InternalOXtype.g:1106:1: ruleXForLoopExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXForLoopExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXForLoopExpression"
+
+
+    // $ANTLR start "ruleXForLoopExpression"
+    // InternalOXtype.g:1113:1: ruleXForLoopExpression : ( ( rule__XForLoopExpression__Group__0 ) ) ;
+    public final void ruleXForLoopExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1117:2: ( ( ( rule__XForLoopExpression__Group__0 ) ) )
+            // InternalOXtype.g:1118:2: ( ( rule__XForLoopExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1118:2: ( ( rule__XForLoopExpression__Group__0 ) )
+            // InternalOXtype.g:1119:3: ( rule__XForLoopExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1120:3: ( rule__XForLoopExpression__Group__0 )
+            // InternalOXtype.g:1120:4: rule__XForLoopExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXForLoopExpression"
+
+
+    // $ANTLR start "entryRuleXBasicForLoopExpression"
+    // InternalOXtype.g:1129:1: entryRuleXBasicForLoopExpression : ruleXBasicForLoopExpression EOF ;
+    public final void entryRuleXBasicForLoopExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1130:1: ( ruleXBasicForLoopExpression EOF )
+            // InternalOXtype.g:1131:1: ruleXBasicForLoopExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXBasicForLoopExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXBasicForLoopExpression"
+
+
+    // $ANTLR start "ruleXBasicForLoopExpression"
+    // InternalOXtype.g:1138:1: ruleXBasicForLoopExpression : ( ( rule__XBasicForLoopExpression__Group__0 ) ) ;
+    public final void ruleXBasicForLoopExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1142:2: ( ( ( rule__XBasicForLoopExpression__Group__0 ) ) )
+            // InternalOXtype.g:1143:2: ( ( rule__XBasicForLoopExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1143:2: ( ( rule__XBasicForLoopExpression__Group__0 ) )
+            // InternalOXtype.g:1144:3: ( rule__XBasicForLoopExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1145:3: ( rule__XBasicForLoopExpression__Group__0 )
+            // InternalOXtype.g:1145:4: rule__XBasicForLoopExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXBasicForLoopExpression"
+
+
+    // $ANTLR start "entryRuleXWhileExpression"
+    // InternalOXtype.g:1154:1: entryRuleXWhileExpression : ruleXWhileExpression EOF ;
+    public final void entryRuleXWhileExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1155:1: ( ruleXWhileExpression EOF )
+            // InternalOXtype.g:1156:1: ruleXWhileExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXWhileExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXWhileExpression"
+
+
+    // $ANTLR start "ruleXWhileExpression"
+    // InternalOXtype.g:1163:1: ruleXWhileExpression : ( ( rule__XWhileExpression__Group__0 ) ) ;
+    public final void ruleXWhileExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1167:2: ( ( ( rule__XWhileExpression__Group__0 ) ) )
+            // InternalOXtype.g:1168:2: ( ( rule__XWhileExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1168:2: ( ( rule__XWhileExpression__Group__0 ) )
+            // InternalOXtype.g:1169:3: ( rule__XWhileExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1170:3: ( rule__XWhileExpression__Group__0 )
+            // InternalOXtype.g:1170:4: rule__XWhileExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXWhileExpression"
+
+
+    // $ANTLR start "entryRuleXDoWhileExpression"
+    // InternalOXtype.g:1179:1: entryRuleXDoWhileExpression : ruleXDoWhileExpression EOF ;
+    public final void entryRuleXDoWhileExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1180:1: ( ruleXDoWhileExpression EOF )
+            // InternalOXtype.g:1181:1: ruleXDoWhileExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXDoWhileExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXDoWhileExpression"
+
+
+    // $ANTLR start "ruleXDoWhileExpression"
+    // InternalOXtype.g:1188:1: ruleXDoWhileExpression : ( ( rule__XDoWhileExpression__Group__0 ) ) ;
+    public final void ruleXDoWhileExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1192:2: ( ( ( rule__XDoWhileExpression__Group__0 ) ) )
+            // InternalOXtype.g:1193:2: ( ( rule__XDoWhileExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1193:2: ( ( rule__XDoWhileExpression__Group__0 ) )
+            // InternalOXtype.g:1194:3: ( rule__XDoWhileExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1195:3: ( rule__XDoWhileExpression__Group__0 )
+            // InternalOXtype.g:1195:4: rule__XDoWhileExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXDoWhileExpression"
+
+
+    // $ANTLR start "entryRuleXBlockExpression"
+    // InternalOXtype.g:1204:1: entryRuleXBlockExpression : ruleXBlockExpression EOF ;
+    public final void entryRuleXBlockExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1205:1: ( ruleXBlockExpression EOF )
+            // InternalOXtype.g:1206:1: ruleXBlockExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXBlockExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXBlockExpression"
+
+
+    // $ANTLR start "ruleXBlockExpression"
+    // InternalOXtype.g:1213:1: ruleXBlockExpression : ( ( rule__XBlockExpression__Group__0 ) ) ;
+    public final void ruleXBlockExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1217:2: ( ( ( rule__XBlockExpression__Group__0 ) ) )
+            // InternalOXtype.g:1218:2: ( ( rule__XBlockExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1218:2: ( ( rule__XBlockExpression__Group__0 ) )
+            // InternalOXtype.g:1219:3: ( rule__XBlockExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1220:3: ( rule__XBlockExpression__Group__0 )
+            // InternalOXtype.g:1220:4: rule__XBlockExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXBlockExpression"
+
+
+    // $ANTLR start "entryRuleXExpressionOrVarDeclaration"
+    // InternalOXtype.g:1229:1: entryRuleXExpressionOrVarDeclaration : ruleXExpressionOrVarDeclaration EOF ;
+    public final void entryRuleXExpressionOrVarDeclaration() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1230:1: ( ruleXExpressionOrVarDeclaration EOF )
+            // InternalOXtype.g:1231:1: ruleXExpressionOrVarDeclaration EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionOrVarDeclarationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXExpressionOrVarDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionOrVarDeclarationRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXExpressionOrVarDeclaration"
+
+
+    // $ANTLR start "ruleXExpressionOrVarDeclaration"
+    // InternalOXtype.g:1238:1: ruleXExpressionOrVarDeclaration : ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) ;
+    public final void ruleXExpressionOrVarDeclaration() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1242:2: ( ( ( rule__XExpressionOrVarDeclaration__Alternatives ) ) )
+            // InternalOXtype.g:1243:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) )
+            {
+            // InternalOXtype.g:1243:2: ( ( rule__XExpressionOrVarDeclaration__Alternatives ) )
+            // InternalOXtype.g:1244:3: ( rule__XExpressionOrVarDeclaration__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:1245:3: ( rule__XExpressionOrVarDeclaration__Alternatives )
+            // InternalOXtype.g:1245:4: rule__XExpressionOrVarDeclaration__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__XExpressionOrVarDeclaration__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXExpressionOrVarDeclaration"
+
+
+    // $ANTLR start "entryRuleXVariableDeclaration"
+    // InternalOXtype.g:1254:1: entryRuleXVariableDeclaration : ruleXVariableDeclaration EOF ;
+    public final void entryRuleXVariableDeclaration() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1255:1: ( ruleXVariableDeclaration EOF )
+            // InternalOXtype.g:1256:1: ruleXVariableDeclaration EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXVariableDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXVariableDeclaration"
+
+
+    // $ANTLR start "ruleXVariableDeclaration"
+    // InternalOXtype.g:1263:1: ruleXVariableDeclaration : ( ( rule__XVariableDeclaration__Group__0 ) ) ;
+    public final void ruleXVariableDeclaration() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1267:2: ( ( ( rule__XVariableDeclaration__Group__0 ) ) )
+            // InternalOXtype.g:1268:2: ( ( rule__XVariableDeclaration__Group__0 ) )
+            {
+            // InternalOXtype.g:1268:2: ( ( rule__XVariableDeclaration__Group__0 ) )
+            // InternalOXtype.g:1269:3: ( rule__XVariableDeclaration__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1270:3: ( rule__XVariableDeclaration__Group__0 )
+            // InternalOXtype.g:1270:4: rule__XVariableDeclaration__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXVariableDeclaration"
+
+
+    // $ANTLR start "entryRuleJvmFormalParameter"
+    // InternalOXtype.g:1279:1: entryRuleJvmFormalParameter : ruleJvmFormalParameter EOF ;
+    public final void entryRuleJvmFormalParameter() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1280:1: ( ruleJvmFormalParameter EOF )
+            // InternalOXtype.g:1281:1: ruleJvmFormalParameter EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmFormalParameterRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmFormalParameterRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmFormalParameter"
+
+
+    // $ANTLR start "ruleJvmFormalParameter"
+    // InternalOXtype.g:1288:1: ruleJvmFormalParameter : ( ( rule__JvmFormalParameter__Group__0 ) ) ;
+    public final void ruleJvmFormalParameter() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1292:2: ( ( ( rule__JvmFormalParameter__Group__0 ) ) )
+            // InternalOXtype.g:1293:2: ( ( rule__JvmFormalParameter__Group__0 ) )
+            {
+            // InternalOXtype.g:1293:2: ( ( rule__JvmFormalParameter__Group__0 ) )
+            // InternalOXtype.g:1294:3: ( rule__JvmFormalParameter__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmFormalParameterAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1295:3: ( rule__JvmFormalParameter__Group__0 )
+            // InternalOXtype.g:1295:4: rule__JvmFormalParameter__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmFormalParameter__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmFormalParameterAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmFormalParameter"
+
+
+    // $ANTLR start "entryRuleFullJvmFormalParameter"
+    // InternalOXtype.g:1304:1: entryRuleFullJvmFormalParameter : ruleFullJvmFormalParameter EOF ;
+    public final void entryRuleFullJvmFormalParameter() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1305:1: ( ruleFullJvmFormalParameter EOF )
+            // InternalOXtype.g:1306:1: ruleFullJvmFormalParameter EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFullJvmFormalParameterRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleFullJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFullJvmFormalParameterRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleFullJvmFormalParameter"
+
+
+    // $ANTLR start "ruleFullJvmFormalParameter"
+    // InternalOXtype.g:1313:1: ruleFullJvmFormalParameter : ( ( rule__FullJvmFormalParameter__Group__0 ) ) ;
+    public final void ruleFullJvmFormalParameter() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1317:2: ( ( ( rule__FullJvmFormalParameter__Group__0 ) ) )
+            // InternalOXtype.g:1318:2: ( ( rule__FullJvmFormalParameter__Group__0 ) )
+            {
+            // InternalOXtype.g:1318:2: ( ( rule__FullJvmFormalParameter__Group__0 ) )
+            // InternalOXtype.g:1319:3: ( rule__FullJvmFormalParameter__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1320:3: ( rule__FullJvmFormalParameter__Group__0 )
+            // InternalOXtype.g:1320:4: rule__FullJvmFormalParameter__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__FullJvmFormalParameter__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleFullJvmFormalParameter"
+
+
+    // $ANTLR start "entryRuleXFeatureCall"
+    // InternalOXtype.g:1329:1: entryRuleXFeatureCall : ruleXFeatureCall EOF ;
+    public final void entryRuleXFeatureCall() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1330:1: ( ruleXFeatureCall EOF )
+            // InternalOXtype.g:1331:1: ruleXFeatureCall EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXFeatureCall();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXFeatureCall"
+
+
+    // $ANTLR start "ruleXFeatureCall"
+    // InternalOXtype.g:1338:1: ruleXFeatureCall : ( ( rule__XFeatureCall__Group__0 ) ) ;
+    public final void ruleXFeatureCall() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1342:2: ( ( ( rule__XFeatureCall__Group__0 ) ) )
+            // InternalOXtype.g:1343:2: ( ( rule__XFeatureCall__Group__0 ) )
+            {
+            // InternalOXtype.g:1343:2: ( ( rule__XFeatureCall__Group__0 ) )
+            // InternalOXtype.g:1344:3: ( rule__XFeatureCall__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1345:3: ( rule__XFeatureCall__Group__0 )
+            // InternalOXtype.g:1345:4: rule__XFeatureCall__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXFeatureCall"
+
+
+    // $ANTLR start "entryRuleFeatureCallID"
+    // InternalOXtype.g:1354:1: entryRuleFeatureCallID : ruleFeatureCallID EOF ;
+    public final void entryRuleFeatureCallID() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1355:1: ( ruleFeatureCallID EOF )
+            // InternalOXtype.g:1356:1: ruleFeatureCallID EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFeatureCallIDRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleFeatureCallID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFeatureCallIDRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleFeatureCallID"
+
+
+    // $ANTLR start "ruleFeatureCallID"
+    // InternalOXtype.g:1363:1: ruleFeatureCallID : ( ( rule__FeatureCallID__Alternatives ) ) ;
+    public final void ruleFeatureCallID() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1367:2: ( ( ( rule__FeatureCallID__Alternatives ) ) )
+            // InternalOXtype.g:1368:2: ( ( rule__FeatureCallID__Alternatives ) )
+            {
+            // InternalOXtype.g:1368:2: ( ( rule__FeatureCallID__Alternatives ) )
+            // InternalOXtype.g:1369:3: ( rule__FeatureCallID__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:1370:3: ( rule__FeatureCallID__Alternatives )
+            // InternalOXtype.g:1370:4: rule__FeatureCallID__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__FeatureCallID__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleFeatureCallID"
+
+
+    // $ANTLR start "entryRuleIdOrSuper"
+    // InternalOXtype.g:1379:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ;
+    public final void entryRuleIdOrSuper() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1380:1: ( ruleIdOrSuper EOF )
+            // InternalOXtype.g:1381:1: ruleIdOrSuper EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getIdOrSuperRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleIdOrSuper();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getIdOrSuperRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleIdOrSuper"
+
+
+    // $ANTLR start "ruleIdOrSuper"
+    // InternalOXtype.g:1388:1: ruleIdOrSuper : ( ( rule__IdOrSuper__Alternatives ) ) ;
+    public final void ruleIdOrSuper() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1392:2: ( ( ( rule__IdOrSuper__Alternatives ) ) )
+            // InternalOXtype.g:1393:2: ( ( rule__IdOrSuper__Alternatives ) )
+            {
+            // InternalOXtype.g:1393:2: ( ( rule__IdOrSuper__Alternatives ) )
+            // InternalOXtype.g:1394:3: ( rule__IdOrSuper__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getIdOrSuperAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:1395:3: ( rule__IdOrSuper__Alternatives )
+            // InternalOXtype.g:1395:4: rule__IdOrSuper__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__IdOrSuper__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getIdOrSuperAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleIdOrSuper"
+
+
+    // $ANTLR start "entryRuleXConstructorCall"
+    // InternalOXtype.g:1404:1: entryRuleXConstructorCall : ruleXConstructorCall EOF ;
+    public final void entryRuleXConstructorCall() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1405:1: ( ruleXConstructorCall EOF )
+            // InternalOXtype.g:1406:1: ruleXConstructorCall EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXConstructorCall();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXConstructorCall"
+
+
+    // $ANTLR start "ruleXConstructorCall"
+    // InternalOXtype.g:1413:1: ruleXConstructorCall : ( ( rule__XConstructorCall__Group__0 ) ) ;
+    public final void ruleXConstructorCall() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1417:2: ( ( ( rule__XConstructorCall__Group__0 ) ) )
+            // InternalOXtype.g:1418:2: ( ( rule__XConstructorCall__Group__0 ) )
+            {
+            // InternalOXtype.g:1418:2: ( ( rule__XConstructorCall__Group__0 ) )
+            // InternalOXtype.g:1419:3: ( rule__XConstructorCall__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1420:3: ( rule__XConstructorCall__Group__0 )
+            // InternalOXtype.g:1420:4: rule__XConstructorCall__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXConstructorCall"
+
+
+    // $ANTLR start "entryRuleXBooleanLiteral"
+    // InternalOXtype.g:1429:1: entryRuleXBooleanLiteral : ruleXBooleanLiteral EOF ;
+    public final void entryRuleXBooleanLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1430:1: ( ruleXBooleanLiteral EOF )
+            // InternalOXtype.g:1431:1: ruleXBooleanLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBooleanLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXBooleanLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBooleanLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXBooleanLiteral"
+
+
+    // $ANTLR start "ruleXBooleanLiteral"
+    // InternalOXtype.g:1438:1: ruleXBooleanLiteral : ( ( rule__XBooleanLiteral__Group__0 ) ) ;
+    public final void ruleXBooleanLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1442:2: ( ( ( rule__XBooleanLiteral__Group__0 ) ) )
+            // InternalOXtype.g:1443:2: ( ( rule__XBooleanLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:1443:2: ( ( rule__XBooleanLiteral__Group__0 ) )
+            // InternalOXtype.g:1444:3: ( rule__XBooleanLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBooleanLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1445:3: ( rule__XBooleanLiteral__Group__0 )
+            // InternalOXtype.g:1445:4: rule__XBooleanLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBooleanLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBooleanLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXBooleanLiteral"
+
+
+    // $ANTLR start "entryRuleXNullLiteral"
+    // InternalOXtype.g:1454:1: entryRuleXNullLiteral : ruleXNullLiteral EOF ;
+    public final void entryRuleXNullLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1455:1: ( ruleXNullLiteral EOF )
+            // InternalOXtype.g:1456:1: ruleXNullLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNullLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXNullLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNullLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXNullLiteral"
+
+
+    // $ANTLR start "ruleXNullLiteral"
+    // InternalOXtype.g:1463:1: ruleXNullLiteral : ( ( rule__XNullLiteral__Group__0 ) ) ;
+    public final void ruleXNullLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1467:2: ( ( ( rule__XNullLiteral__Group__0 ) ) )
+            // InternalOXtype.g:1468:2: ( ( rule__XNullLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:1468:2: ( ( rule__XNullLiteral__Group__0 ) )
+            // InternalOXtype.g:1469:3: ( rule__XNullLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNullLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1470:3: ( rule__XNullLiteral__Group__0 )
+            // InternalOXtype.g:1470:4: rule__XNullLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XNullLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNullLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXNullLiteral"
+
+
+    // $ANTLR start "entryRuleXNumberLiteral"
+    // InternalOXtype.g:1479:1: entryRuleXNumberLiteral : ruleXNumberLiteral EOF ;
+    public final void entryRuleXNumberLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1480:1: ( ruleXNumberLiteral EOF )
+            // InternalOXtype.g:1481:1: ruleXNumberLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNumberLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXNumberLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNumberLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXNumberLiteral"
+
+
+    // $ANTLR start "ruleXNumberLiteral"
+    // InternalOXtype.g:1488:1: ruleXNumberLiteral : ( ( rule__XNumberLiteral__Group__0 ) ) ;
+    public final void ruleXNumberLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1492:2: ( ( ( rule__XNumberLiteral__Group__0 ) ) )
+            // InternalOXtype.g:1493:2: ( ( rule__XNumberLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:1493:2: ( ( rule__XNumberLiteral__Group__0 ) )
+            // InternalOXtype.g:1494:3: ( rule__XNumberLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNumberLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1495:3: ( rule__XNumberLiteral__Group__0 )
+            // InternalOXtype.g:1495:4: rule__XNumberLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XNumberLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNumberLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXNumberLiteral"
+
+
+    // $ANTLR start "entryRuleXStringLiteral"
+    // InternalOXtype.g:1504:1: entryRuleXStringLiteral : ruleXStringLiteral EOF ;
+    public final void entryRuleXStringLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1505:1: ( ruleXStringLiteral EOF )
+            // InternalOXtype.g:1506:1: ruleXStringLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXStringLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXStringLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXStringLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXStringLiteral"
+
+
+    // $ANTLR start "ruleXStringLiteral"
+    // InternalOXtype.g:1513:1: ruleXStringLiteral : ( ( rule__XStringLiteral__Group__0 ) ) ;
+    public final void ruleXStringLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1517:2: ( ( ( rule__XStringLiteral__Group__0 ) ) )
+            // InternalOXtype.g:1518:2: ( ( rule__XStringLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:1518:2: ( ( rule__XStringLiteral__Group__0 ) )
+            // InternalOXtype.g:1519:3: ( rule__XStringLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXStringLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1520:3: ( rule__XStringLiteral__Group__0 )
+            // InternalOXtype.g:1520:4: rule__XStringLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XStringLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXStringLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXStringLiteral"
+
+
+    // $ANTLR start "entryRuleXTypeLiteral"
+    // InternalOXtype.g:1529:1: entryRuleXTypeLiteral : ruleXTypeLiteral EOF ;
+    public final void entryRuleXTypeLiteral() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1530:1: ( ruleXTypeLiteral EOF )
+            // InternalOXtype.g:1531:1: ruleXTypeLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXTypeLiteral();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXTypeLiteral"
+
+
+    // $ANTLR start "ruleXTypeLiteral"
+    // InternalOXtype.g:1538:1: ruleXTypeLiteral : ( ( rule__XTypeLiteral__Group__0 ) ) ;
+    public final void ruleXTypeLiteral() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1542:2: ( ( ( rule__XTypeLiteral__Group__0 ) ) )
+            // InternalOXtype.g:1543:2: ( ( rule__XTypeLiteral__Group__0 ) )
+            {
+            // InternalOXtype.g:1543:2: ( ( rule__XTypeLiteral__Group__0 ) )
+            // InternalOXtype.g:1544:3: ( rule__XTypeLiteral__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1545:3: ( rule__XTypeLiteral__Group__0 )
+            // InternalOXtype.g:1545:4: rule__XTypeLiteral__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXTypeLiteral"
+
+
+    // $ANTLR start "entryRuleXThrowExpression"
+    // InternalOXtype.g:1554:1: entryRuleXThrowExpression : ruleXThrowExpression EOF ;
+    public final void entryRuleXThrowExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1555:1: ( ruleXThrowExpression EOF )
+            // InternalOXtype.g:1556:1: ruleXThrowExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXThrowExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXThrowExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXThrowExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXThrowExpression"
+
+
+    // $ANTLR start "ruleXThrowExpression"
+    // InternalOXtype.g:1563:1: ruleXThrowExpression : ( ( rule__XThrowExpression__Group__0 ) ) ;
+    public final void ruleXThrowExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1567:2: ( ( ( rule__XThrowExpression__Group__0 ) ) )
+            // InternalOXtype.g:1568:2: ( ( rule__XThrowExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1568:2: ( ( rule__XThrowExpression__Group__0 ) )
+            // InternalOXtype.g:1569:3: ( rule__XThrowExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXThrowExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1570:3: ( rule__XThrowExpression__Group__0 )
+            // InternalOXtype.g:1570:4: rule__XThrowExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XThrowExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXThrowExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXThrowExpression"
+
+
+    // $ANTLR start "entryRuleXReturnExpression"
+    // InternalOXtype.g:1579:1: entryRuleXReturnExpression : ruleXReturnExpression EOF ;
+    public final void entryRuleXReturnExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1580:1: ( ruleXReturnExpression EOF )
+            // InternalOXtype.g:1581:1: ruleXReturnExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXReturnExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXReturnExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXReturnExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXReturnExpression"
+
+
+    // $ANTLR start "ruleXReturnExpression"
+    // InternalOXtype.g:1588:1: ruleXReturnExpression : ( ( rule__XReturnExpression__Group__0 ) ) ;
+    public final void ruleXReturnExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1592:2: ( ( ( rule__XReturnExpression__Group__0 ) ) )
+            // InternalOXtype.g:1593:2: ( ( rule__XReturnExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1593:2: ( ( rule__XReturnExpression__Group__0 ) )
+            // InternalOXtype.g:1594:3: ( rule__XReturnExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXReturnExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1595:3: ( rule__XReturnExpression__Group__0 )
+            // InternalOXtype.g:1595:4: rule__XReturnExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XReturnExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXReturnExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXReturnExpression"
+
+
+    // $ANTLR start "entryRuleXTryCatchFinallyExpression"
+    // InternalOXtype.g:1604:1: entryRuleXTryCatchFinallyExpression : ruleXTryCatchFinallyExpression EOF ;
+    public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1605:1: ( ruleXTryCatchFinallyExpression EOF )
+            // InternalOXtype.g:1606:1: ruleXTryCatchFinallyExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXTryCatchFinallyExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXTryCatchFinallyExpression"
+
+
+    // $ANTLR start "ruleXTryCatchFinallyExpression"
+    // InternalOXtype.g:1613:1: ruleXTryCatchFinallyExpression : ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) ;
+    public final void ruleXTryCatchFinallyExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1617:2: ( ( ( rule__XTryCatchFinallyExpression__Group__0 ) ) )
+            // InternalOXtype.g:1618:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1618:2: ( ( rule__XTryCatchFinallyExpression__Group__0 ) )
+            // InternalOXtype.g:1619:3: ( rule__XTryCatchFinallyExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1620:3: ( rule__XTryCatchFinallyExpression__Group__0 )
+            // InternalOXtype.g:1620:4: rule__XTryCatchFinallyExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXTryCatchFinallyExpression"
+
+
+    // $ANTLR start "entryRuleXSynchronizedExpression"
+    // InternalOXtype.g:1629:1: entryRuleXSynchronizedExpression : ruleXSynchronizedExpression EOF ;
+    public final void entryRuleXSynchronizedExpression() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1630:1: ( ruleXSynchronizedExpression EOF )
+            // InternalOXtype.g:1631:1: ruleXSynchronizedExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXSynchronizedExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXSynchronizedExpression"
+
+
+    // $ANTLR start "ruleXSynchronizedExpression"
+    // InternalOXtype.g:1638:1: ruleXSynchronizedExpression : ( ( rule__XSynchronizedExpression__Group__0 ) ) ;
+    public final void ruleXSynchronizedExpression() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1642:2: ( ( ( rule__XSynchronizedExpression__Group__0 ) ) )
+            // InternalOXtype.g:1643:2: ( ( rule__XSynchronizedExpression__Group__0 ) )
+            {
+            // InternalOXtype.g:1643:2: ( ( rule__XSynchronizedExpression__Group__0 ) )
+            // InternalOXtype.g:1644:3: ( rule__XSynchronizedExpression__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1645:3: ( rule__XSynchronizedExpression__Group__0 )
+            // InternalOXtype.g:1645:4: rule__XSynchronizedExpression__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXSynchronizedExpression"
+
+
+    // $ANTLR start "entryRuleXCatchClause"
+    // InternalOXtype.g:1654:1: entryRuleXCatchClause : ruleXCatchClause EOF ;
+    public final void entryRuleXCatchClause() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1655:1: ( ruleXCatchClause EOF )
+            // InternalOXtype.g:1656:1: ruleXCatchClause EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXCatchClause();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXCatchClause"
+
+
+    // $ANTLR start "ruleXCatchClause"
+    // InternalOXtype.g:1663:1: ruleXCatchClause : ( ( rule__XCatchClause__Group__0 ) ) ;
+    public final void ruleXCatchClause() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1667:2: ( ( ( rule__XCatchClause__Group__0 ) ) )
+            // InternalOXtype.g:1668:2: ( ( rule__XCatchClause__Group__0 ) )
+            {
+            // InternalOXtype.g:1668:2: ( ( rule__XCatchClause__Group__0 ) )
+            // InternalOXtype.g:1669:3: ( rule__XCatchClause__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1670:3: ( rule__XCatchClause__Group__0 )
+            // InternalOXtype.g:1670:4: rule__XCatchClause__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXCatchClause"
+
+
+    // $ANTLR start "entryRuleQualifiedName"
+    // InternalOXtype.g:1679:1: entryRuleQualifiedName : ruleQualifiedName EOF ;
+    public final void entryRuleQualifiedName() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1680:1: ( ruleQualifiedName EOF )
+            // InternalOXtype.g:1681:1: ruleQualifiedName EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleQualifiedName"
+
+
+    // $ANTLR start "ruleQualifiedName"
+    // InternalOXtype.g:1688:1: ruleQualifiedName : ( ( rule__QualifiedName__Group__0 ) ) ;
+    public final void ruleQualifiedName() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1692:2: ( ( ( rule__QualifiedName__Group__0 ) ) )
+            // InternalOXtype.g:1693:2: ( ( rule__QualifiedName__Group__0 ) )
+            {
+            // InternalOXtype.g:1693:2: ( ( rule__QualifiedName__Group__0 ) )
+            // InternalOXtype.g:1694:3: ( rule__QualifiedName__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1695:3: ( rule__QualifiedName__Group__0 )
+            // InternalOXtype.g:1695:4: rule__QualifiedName__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedName__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleQualifiedName"
+
+
+    // $ANTLR start "entryRuleNumber"
+    // InternalOXtype.g:1704:1: entryRuleNumber : ruleNumber EOF ;
+    public final void entryRuleNumber() throws RecognitionException {
+         
+        	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+
+        try {
+            // InternalOXtype.g:1708:1: ( ruleNumber EOF )
+            // InternalOXtype.g:1709:1: ruleNumber EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getNumberRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleNumber();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getNumberRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	myHiddenTokenState.restore();
+
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleNumber"
+
+
+    // $ANTLR start "ruleNumber"
+    // InternalOXtype.g:1719:1: ruleNumber : ( ( rule__Number__Alternatives ) ) ;
+    public final void ruleNumber() throws RecognitionException {
+
+        		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1724:2: ( ( ( rule__Number__Alternatives ) ) )
+            // InternalOXtype.g:1725:2: ( ( rule__Number__Alternatives ) )
+            {
+            // InternalOXtype.g:1725:2: ( ( rule__Number__Alternatives ) )
+            // InternalOXtype.g:1726:3: ( rule__Number__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getNumberAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:1727:3: ( rule__Number__Alternatives )
+            // InternalOXtype.g:1727:4: rule__Number__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__Number__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getNumberAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+            	myHiddenTokenState.restore();
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleNumber"
+
+
+    // $ANTLR start "entryRuleJvmTypeReference"
+    // InternalOXtype.g:1737:1: entryRuleJvmTypeReference : ruleJvmTypeReference EOF ;
+    public final void entryRuleJvmTypeReference() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1738:1: ( ruleJvmTypeReference EOF )
+            // InternalOXtype.g:1739:1: ruleJvmTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmTypeReference"
+
+
+    // $ANTLR start "ruleJvmTypeReference"
+    // InternalOXtype.g:1746:1: ruleJvmTypeReference : ( ( rule__JvmTypeReference__Alternatives ) ) ;
+    public final void ruleJvmTypeReference() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1750:2: ( ( ( rule__JvmTypeReference__Alternatives ) ) )
+            // InternalOXtype.g:1751:2: ( ( rule__JvmTypeReference__Alternatives ) )
+            {
+            // InternalOXtype.g:1751:2: ( ( rule__JvmTypeReference__Alternatives ) )
+            // InternalOXtype.g:1752:3: ( rule__JvmTypeReference__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:1753:3: ( rule__JvmTypeReference__Alternatives )
+            // InternalOXtype.g:1753:4: rule__JvmTypeReference__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmTypeReference"
+
+
+    // $ANTLR start "entryRuleArrayBrackets"
+    // InternalOXtype.g:1762:1: entryRuleArrayBrackets : ruleArrayBrackets EOF ;
+    public final void entryRuleArrayBrackets() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1763:1: ( ruleArrayBrackets EOF )
+            // InternalOXtype.g:1764:1: ruleArrayBrackets EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getArrayBracketsRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleArrayBrackets();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getArrayBracketsRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleArrayBrackets"
+
+
+    // $ANTLR start "ruleArrayBrackets"
+    // InternalOXtype.g:1771:1: ruleArrayBrackets : ( ( rule__ArrayBrackets__Group__0 ) ) ;
+    public final void ruleArrayBrackets() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1775:2: ( ( ( rule__ArrayBrackets__Group__0 ) ) )
+            // InternalOXtype.g:1776:2: ( ( rule__ArrayBrackets__Group__0 ) )
+            {
+            // InternalOXtype.g:1776:2: ( ( rule__ArrayBrackets__Group__0 ) )
+            // InternalOXtype.g:1777:3: ( rule__ArrayBrackets__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getArrayBracketsAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1778:3: ( rule__ArrayBrackets__Group__0 )
+            // InternalOXtype.g:1778:4: rule__ArrayBrackets__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__ArrayBrackets__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getArrayBracketsAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleArrayBrackets"
+
+
+    // $ANTLR start "entryRuleXFunctionTypeRef"
+    // InternalOXtype.g:1787:1: entryRuleXFunctionTypeRef : ruleXFunctionTypeRef EOF ;
+    public final void entryRuleXFunctionTypeRef() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1788:1: ( ruleXFunctionTypeRef EOF )
+            // InternalOXtype.g:1789:1: ruleXFunctionTypeRef EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleXFunctionTypeRef();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleXFunctionTypeRef"
+
+
+    // $ANTLR start "ruleXFunctionTypeRef"
+    // InternalOXtype.g:1796:1: ruleXFunctionTypeRef : ( ( rule__XFunctionTypeRef__Group__0 ) ) ;
+    public final void ruleXFunctionTypeRef() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1800:2: ( ( ( rule__XFunctionTypeRef__Group__0 ) ) )
+            // InternalOXtype.g:1801:2: ( ( rule__XFunctionTypeRef__Group__0 ) )
+            {
+            // InternalOXtype.g:1801:2: ( ( rule__XFunctionTypeRef__Group__0 ) )
+            // InternalOXtype.g:1802:3: ( rule__XFunctionTypeRef__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1803:3: ( rule__XFunctionTypeRef__Group__0 )
+            // InternalOXtype.g:1803:4: rule__XFunctionTypeRef__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleXFunctionTypeRef"
+
+
+    // $ANTLR start "entryRuleJvmParameterizedTypeReference"
+    // InternalOXtype.g:1812:1: entryRuleJvmParameterizedTypeReference : ruleJvmParameterizedTypeReference EOF ;
+    public final void entryRuleJvmParameterizedTypeReference() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1813:1: ( ruleJvmParameterizedTypeReference EOF )
+            // InternalOXtype.g:1814:1: ruleJvmParameterizedTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmParameterizedTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmParameterizedTypeReference"
+
+
+    // $ANTLR start "ruleJvmParameterizedTypeReference"
+    // InternalOXtype.g:1821:1: ruleJvmParameterizedTypeReference : ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) ;
+    public final void ruleJvmParameterizedTypeReference() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1825:2: ( ( ( rule__JvmParameterizedTypeReference__Group__0 ) ) )
+            // InternalOXtype.g:1826:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) )
+            {
+            // InternalOXtype.g:1826:2: ( ( rule__JvmParameterizedTypeReference__Group__0 ) )
+            // InternalOXtype.g:1827:3: ( rule__JvmParameterizedTypeReference__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1828:3: ( rule__JvmParameterizedTypeReference__Group__0 )
+            // InternalOXtype.g:1828:4: rule__JvmParameterizedTypeReference__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmParameterizedTypeReference"
+
+
+    // $ANTLR start "entryRuleJvmArgumentTypeReference"
+    // InternalOXtype.g:1837:1: entryRuleJvmArgumentTypeReference : ruleJvmArgumentTypeReference EOF ;
+    public final void entryRuleJvmArgumentTypeReference() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1838:1: ( ruleJvmArgumentTypeReference EOF )
+            // InternalOXtype.g:1839:1: ruleJvmArgumentTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmArgumentTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmArgumentTypeReferenceRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmArgumentTypeReference"
+
+
+    // $ANTLR start "ruleJvmArgumentTypeReference"
+    // InternalOXtype.g:1846:1: ruleJvmArgumentTypeReference : ( ( rule__JvmArgumentTypeReference__Alternatives ) ) ;
+    public final void ruleJvmArgumentTypeReference() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1850:2: ( ( ( rule__JvmArgumentTypeReference__Alternatives ) ) )
+            // InternalOXtype.g:1851:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) )
+            {
+            // InternalOXtype.g:1851:2: ( ( rule__JvmArgumentTypeReference__Alternatives ) )
+            // InternalOXtype.g:1852:3: ( rule__JvmArgumentTypeReference__Alternatives )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); 
+            }
+            // InternalOXtype.g:1853:3: ( rule__JvmArgumentTypeReference__Alternatives )
+            // InternalOXtype.g:1853:4: rule__JvmArgumentTypeReference__Alternatives
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmArgumentTypeReference__Alternatives();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmArgumentTypeReferenceAccess().getAlternatives()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmArgumentTypeReference"
+
+
+    // $ANTLR start "entryRuleJvmWildcardTypeReference"
+    // InternalOXtype.g:1862:1: entryRuleJvmWildcardTypeReference : ruleJvmWildcardTypeReference EOF ;
+    public final void entryRuleJvmWildcardTypeReference() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1863:1: ( ruleJvmWildcardTypeReference EOF )
+            // InternalOXtype.g:1864:1: ruleJvmWildcardTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmWildcardTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmWildcardTypeReference"
+
+
+    // $ANTLR start "ruleJvmWildcardTypeReference"
+    // InternalOXtype.g:1871:1: ruleJvmWildcardTypeReference : ( ( rule__JvmWildcardTypeReference__Group__0 ) ) ;
+    public final void ruleJvmWildcardTypeReference() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1875:2: ( ( ( rule__JvmWildcardTypeReference__Group__0 ) ) )
+            // InternalOXtype.g:1876:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) )
+            {
+            // InternalOXtype.g:1876:2: ( ( rule__JvmWildcardTypeReference__Group__0 ) )
+            // InternalOXtype.g:1877:3: ( rule__JvmWildcardTypeReference__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1878:3: ( rule__JvmWildcardTypeReference__Group__0 )
+            // InternalOXtype.g:1878:4: rule__JvmWildcardTypeReference__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmWildcardTypeReference"
+
+
+    // $ANTLR start "entryRuleJvmUpperBound"
+    // InternalOXtype.g:1887:1: entryRuleJvmUpperBound : ruleJvmUpperBound EOF ;
+    public final void entryRuleJvmUpperBound() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1888:1: ( ruleJvmUpperBound EOF )
+            // InternalOXtype.g:1889:1: ruleJvmUpperBound EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmUpperBound();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmUpperBound"
+
+
+    // $ANTLR start "ruleJvmUpperBound"
+    // InternalOXtype.g:1896:1: ruleJvmUpperBound : ( ( rule__JvmUpperBound__Group__0 ) ) ;
+    public final void ruleJvmUpperBound() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1900:2: ( ( ( rule__JvmUpperBound__Group__0 ) ) )
+            // InternalOXtype.g:1901:2: ( ( rule__JvmUpperBound__Group__0 ) )
+            {
+            // InternalOXtype.g:1901:2: ( ( rule__JvmUpperBound__Group__0 ) )
+            // InternalOXtype.g:1902:3: ( rule__JvmUpperBound__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1903:3: ( rule__JvmUpperBound__Group__0 )
+            // InternalOXtype.g:1903:4: rule__JvmUpperBound__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBound__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmUpperBound"
+
+
+    // $ANTLR start "entryRuleJvmUpperBoundAnded"
+    // InternalOXtype.g:1912:1: entryRuleJvmUpperBoundAnded : ruleJvmUpperBoundAnded EOF ;
+    public final void entryRuleJvmUpperBoundAnded() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1913:1: ( ruleJvmUpperBoundAnded EOF )
+            // InternalOXtype.g:1914:1: ruleJvmUpperBoundAnded EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAndedRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmUpperBoundAnded();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAndedRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmUpperBoundAnded"
+
+
+    // $ANTLR start "ruleJvmUpperBoundAnded"
+    // InternalOXtype.g:1921:1: ruleJvmUpperBoundAnded : ( ( rule__JvmUpperBoundAnded__Group__0 ) ) ;
+    public final void ruleJvmUpperBoundAnded() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1925:2: ( ( ( rule__JvmUpperBoundAnded__Group__0 ) ) )
+            // InternalOXtype.g:1926:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) )
+            {
+            // InternalOXtype.g:1926:2: ( ( rule__JvmUpperBoundAnded__Group__0 ) )
+            // InternalOXtype.g:1927:3: ( rule__JvmUpperBoundAnded__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1928:3: ( rule__JvmUpperBoundAnded__Group__0 )
+            // InternalOXtype.g:1928:4: rule__JvmUpperBoundAnded__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBoundAnded__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAndedAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmUpperBoundAnded"
+
+
+    // $ANTLR start "entryRuleJvmLowerBound"
+    // InternalOXtype.g:1937:1: entryRuleJvmLowerBound : ruleJvmLowerBound EOF ;
+    public final void entryRuleJvmLowerBound() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1938:1: ( ruleJvmLowerBound EOF )
+            // InternalOXtype.g:1939:1: ruleJvmLowerBound EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmLowerBound();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmLowerBound"
+
+
+    // $ANTLR start "ruleJvmLowerBound"
+    // InternalOXtype.g:1946:1: ruleJvmLowerBound : ( ( rule__JvmLowerBound__Group__0 ) ) ;
+    public final void ruleJvmLowerBound() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1950:2: ( ( ( rule__JvmLowerBound__Group__0 ) ) )
+            // InternalOXtype.g:1951:2: ( ( rule__JvmLowerBound__Group__0 ) )
+            {
+            // InternalOXtype.g:1951:2: ( ( rule__JvmLowerBound__Group__0 ) )
+            // InternalOXtype.g:1952:3: ( rule__JvmLowerBound__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1953:3: ( rule__JvmLowerBound__Group__0 )
+            // InternalOXtype.g:1953:4: rule__JvmLowerBound__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBound__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmLowerBound"
+
+
+    // $ANTLR start "entryRuleJvmLowerBoundAnded"
+    // InternalOXtype.g:1962:1: entryRuleJvmLowerBoundAnded : ruleJvmLowerBoundAnded EOF ;
+    public final void entryRuleJvmLowerBoundAnded() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1963:1: ( ruleJvmLowerBoundAnded EOF )
+            // InternalOXtype.g:1964:1: ruleJvmLowerBoundAnded EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAndedRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleJvmLowerBoundAnded();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAndedRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleJvmLowerBoundAnded"
+
+
+    // $ANTLR start "ruleJvmLowerBoundAnded"
+    // InternalOXtype.g:1971:1: ruleJvmLowerBoundAnded : ( ( rule__JvmLowerBoundAnded__Group__0 ) ) ;
+    public final void ruleJvmLowerBoundAnded() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:1975:2: ( ( ( rule__JvmLowerBoundAnded__Group__0 ) ) )
+            // InternalOXtype.g:1976:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) )
+            {
+            // InternalOXtype.g:1976:2: ( ( rule__JvmLowerBoundAnded__Group__0 ) )
+            // InternalOXtype.g:1977:3: ( rule__JvmLowerBoundAnded__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); 
+            }
+            // InternalOXtype.g:1978:3: ( rule__JvmLowerBoundAnded__Group__0 )
+            // InternalOXtype.g:1978:4: rule__JvmLowerBoundAnded__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBoundAnded__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAndedAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleJvmLowerBoundAnded"
+
+
+    // $ANTLR start "entryRuleQualifiedNameWithWildcard"
+    // InternalOXtype.g:1987:1: entryRuleQualifiedNameWithWildcard : ruleQualifiedNameWithWildcard EOF ;
+    public final void entryRuleQualifiedNameWithWildcard() throws RecognitionException {
+        try {
+            // InternalOXtype.g:1988:1: ( ruleQualifiedNameWithWildcard EOF )
+            // InternalOXtype.g:1989:1: ruleQualifiedNameWithWildcard EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameWithWildcardRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleQualifiedNameWithWildcard();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameWithWildcardRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleQualifiedNameWithWildcard"
+
+
+    // $ANTLR start "ruleQualifiedNameWithWildcard"
+    // InternalOXtype.g:1996:1: ruleQualifiedNameWithWildcard : ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) ;
+    public final void ruleQualifiedNameWithWildcard() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2000:2: ( ( ( rule__QualifiedNameWithWildcard__Group__0 ) ) )
+            // InternalOXtype.g:2001:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) )
+            {
+            // InternalOXtype.g:2001:2: ( ( rule__QualifiedNameWithWildcard__Group__0 ) )
+            // InternalOXtype.g:2002:3: ( rule__QualifiedNameWithWildcard__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); 
+            }
+            // InternalOXtype.g:2003:3: ( rule__QualifiedNameWithWildcard__Group__0 )
+            // InternalOXtype.g:2003:4: rule__QualifiedNameWithWildcard__Group__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameWithWildcardAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleQualifiedNameWithWildcard"
+
+
+    // $ANTLR start "entryRuleValidID"
+    // InternalOXtype.g:2012:1: entryRuleValidID : ruleValidID EOF ;
+    public final void entryRuleValidID() throws RecognitionException {
+        try {
+            // InternalOXtype.g:2013:1: ( ruleValidID EOF )
+            // InternalOXtype.g:2014:1: ruleValidID EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getValidIDRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getValidIDRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleValidID"
+
+
+    // $ANTLR start "ruleValidID"
+    // InternalOXtype.g:2021:1: ruleValidID : ( RULE_ID ) ;
+    public final void ruleValidID() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2025:2: ( ( RULE_ID ) )
+            // InternalOXtype.g:2026:2: ( RULE_ID )
+            {
+            // InternalOXtype.g:2026:2: ( RULE_ID )
+            // InternalOXtype.g:2027:3: RULE_ID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); 
+            }
+            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleValidID"
+
+
+    // $ANTLR start "entryRuleQualifiedNameInStaticImport"
+    // InternalOXtype.g:2037:1: entryRuleQualifiedNameInStaticImport : ruleQualifiedNameInStaticImport EOF ;
+    public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException {
+        try {
+            // InternalOXtype.g:2038:1: ( ruleQualifiedNameInStaticImport EOF )
+            // InternalOXtype.g:2039:1: ruleQualifiedNameInStaticImport EOF
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameInStaticImportRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            ruleQualifiedNameInStaticImport();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameInStaticImportRule()); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+        }
+        return ;
+    }
+    // $ANTLR end "entryRuleQualifiedNameInStaticImport"
+
+
+    // $ANTLR start "ruleQualifiedNameInStaticImport"
+    // InternalOXtype.g:2046:1: ruleQualifiedNameInStaticImport : ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) ;
+    public final void ruleQualifiedNameInStaticImport() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2050:2: ( ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) ) )
+            // InternalOXtype.g:2051:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) )
+            {
+            // InternalOXtype.g:2051:2: ( ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* ) )
+            // InternalOXtype.g:2052:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) ) ( ( rule__QualifiedNameInStaticImport__Group__0 )* )
+            {
+            // InternalOXtype.g:2052:3: ( ( rule__QualifiedNameInStaticImport__Group__0 ) )
+            // InternalOXtype.g:2053:4: ( rule__QualifiedNameInStaticImport__Group__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); 
+            }
+            // InternalOXtype.g:2054:4: ( rule__QualifiedNameInStaticImport__Group__0 )
+            // InternalOXtype.g:2054:5: rule__QualifiedNameInStaticImport__Group__0
+            {
+            pushFollow(FOLLOW_3);
+            rule__QualifiedNameInStaticImport__Group__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); 
+            }
+
+            }
+
+            // InternalOXtype.g:2057:3: ( ( rule__QualifiedNameInStaticImport__Group__0 )* )
+            // InternalOXtype.g:2058:4: ( rule__QualifiedNameInStaticImport__Group__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); 
+            }
+            // InternalOXtype.g:2059:4: ( rule__QualifiedNameInStaticImport__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==43) ) {
+                        alt1=1;
+                    }
+
+
+                }
+
+
+                switch (alt1) {
+            	case 1 :
+            	    // InternalOXtype.g:2059:5: rule__QualifiedNameInStaticImport__Group__0
+            	    {
+            	    pushFollow(FOLLOW_3);
+            	    rule__QualifiedNameInStaticImport__Group__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop1;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); 
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "ruleQualifiedNameInStaticImport"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Alternatives_2"
+    // InternalOXtype.g:2068:1: rule__XImportDeclaration__Alternatives_2 : ( ( ( rule__XImportDeclaration__Group_2_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) ) | ( ( rule__XImportDeclaration__Group_2_3__0 ) ) );
+    public final void rule__XImportDeclaration__Alternatives_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2072:1: ( ( ( rule__XImportDeclaration__Group_2_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) ) | ( ( rule__XImportDeclaration__Group_2_3__0 ) ) )
+            int alt2=4;
+            alt2 = dfa2.predict(input);
+            switch (alt2) {
+                case 1 :
+                    // InternalOXtype.g:2073:2: ( ( rule__XImportDeclaration__Group_2_0__0 ) )
+                    {
+                    // InternalOXtype.g:2073:2: ( ( rule__XImportDeclaration__Group_2_0__0 ) )
+                    // InternalOXtype.g:2074:3: ( rule__XImportDeclaration__Group_2_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXImportDeclarationAccess().getGroup_2_0()); 
+                    }
+                    // InternalOXtype.g:2075:3: ( rule__XImportDeclaration__Group_2_0__0 )
+                    // InternalOXtype.g:2075:4: rule__XImportDeclaration__Group_2_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__Group_2_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXImportDeclarationAccess().getGroup_2_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2079:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) )
+                    {
+                    // InternalOXtype.g:2079:2: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) )
+                    // InternalOXtype.g:2080:3: ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1()); 
+                    }
+                    // InternalOXtype.g:2081:3: ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 )
+                    // InternalOXtype.g:2081:4: rule__XImportDeclaration__ImportedTypeAssignment_2_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__ImportedTypeAssignment_2_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2085:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) )
+                    {
+                    // InternalOXtype.g:2085:2: ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) )
+                    // InternalOXtype.g:2086:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2()); 
+                    }
+                    // InternalOXtype.g:2087:3: ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 )
+                    // InternalOXtype.g:2087:4: rule__XImportDeclaration__ImportedNamespaceAssignment_2_2
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__ImportedNamespaceAssignment_2_2();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_2_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2091:2: ( ( rule__XImportDeclaration__Group_2_3__0 ) )
+                    {
+                    // InternalOXtype.g:2091:2: ( ( rule__XImportDeclaration__Group_2_3__0 ) )
+                    // InternalOXtype.g:2092:3: ( rule__XImportDeclaration__Group_2_3__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXImportDeclarationAccess().getGroup_2_3()); 
+                    }
+                    // InternalOXtype.g:2093:3: ( rule__XImportDeclaration__Group_2_3__0 )
+                    // InternalOXtype.g:2093:4: rule__XImportDeclaration__Group_2_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__Group_2_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXImportDeclarationAccess().getGroup_2_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Alternatives_2"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Alternatives_2_0_3"
+    // InternalOXtype.g:2101:1: rule__XImportDeclaration__Alternatives_2_0_3 : ( ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) ) );
+    public final void rule__XImportDeclaration__Alternatives_2_0_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2105:1: ( ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) ) | ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) ) )
+            int alt3=2;
+            int LA3_0 = input.LA(1);
+
+            if ( (LA3_0==36) ) {
+                alt3=1;
+            }
+            else if ( (LA3_0==RULE_ID) ) {
+                alt3=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 3, 0, input);
+
+                throw nvae;
+            }
+            switch (alt3) {
+                case 1 :
+                    // InternalOXtype.g:2106:2: ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) )
+                    {
+                    // InternalOXtype.g:2106:2: ( ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 ) )
+                    // InternalOXtype.g:2107:3: ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0()); 
+                    }
+                    // InternalOXtype.g:2108:3: ( rule__XImportDeclaration__WildcardAssignment_2_0_3_0 )
+                    // InternalOXtype.g:2108:4: rule__XImportDeclaration__WildcardAssignment_2_0_3_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__WildcardAssignment_2_0_3_0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_2_0_3_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2112:2: ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) )
+                    {
+                    // InternalOXtype.g:2112:2: ( ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 ) )
+                    // InternalOXtype.g:2113:3: ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1()); 
+                    }
+                    // InternalOXtype.g:2114:3: ( rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 )
+                    // InternalOXtype.g:2114:4: rule__XImportDeclaration__MemberNameAssignment_2_0_3_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__MemberNameAssignment_2_0_3_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_2_0_3_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Alternatives_2_0_3"
+
+
+    // $ANTLR start "rule__XAnnotation__Alternatives_3_1"
+    // InternalOXtype.g:2122:1: rule__XAnnotation__Alternatives_3_1 : ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) );
+    public final void rule__XAnnotation__Alternatives_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2126:1: ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) )
+            int alt4=2;
+            alt4 = dfa4.predict(input);
+            switch (alt4) {
+                case 1 :
+                    // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+                    {
+                    // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+                    // InternalOXtype.g:2128:3: ( rule__XAnnotation__Group_3_1_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); 
+                    }
+                    // InternalOXtype.g:2129:3: ( rule__XAnnotation__Group_3_1_0__0 )
+                    // InternalOXtype.g:2129:4: rule__XAnnotation__Group_3_1_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotation__Group_3_1_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2133:2: ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) )
+                    {
+                    // InternalOXtype.g:2133:2: ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) )
+                    // InternalOXtype.g:2134:3: ( rule__XAnnotation__ValueAssignment_3_1_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); 
+                    }
+                    // InternalOXtype.g:2135:3: ( rule__XAnnotation__ValueAssignment_3_1_1 )
+                    // InternalOXtype.g:2135:4: rule__XAnnotation__ValueAssignment_3_1_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotation__ValueAssignment_3_1_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationAccess().getValueAssignment_3_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Alternatives_3_1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Alternatives"
+    // InternalOXtype.g:2143:1: rule__XAnnotationElementValueOrCommaList__Alternatives : ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) );
+    public final void rule__XAnnotationElementValueOrCommaList__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2147:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) )
+            int alt5=2;
+            alt5 = dfa5.predict(input);
+            switch (alt5) {
+                case 1 :
+                    // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+                    {
+                    // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+                    // InternalOXtype.g:2149:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); 
+                    }
+                    // InternalOXtype.g:2150:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+                    // InternalOXtype.g:2150:4: rule__XAnnotationElementValueOrCommaList__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotationElementValueOrCommaList__Group_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2154:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) )
+                    {
+                    // InternalOXtype.g:2154:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) )
+                    // InternalOXtype.g:2155:3: ( rule__XAnnotationElementValueOrCommaList__Group_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); 
+                    }
+                    // InternalOXtype.g:2156:3: ( rule__XAnnotationElementValueOrCommaList__Group_1__0 )
+                    // InternalOXtype.g:2156:4: rule__XAnnotationElementValueOrCommaList__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotationElementValueOrCommaList__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Alternatives"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Alternatives"
+    // InternalOXtype.g:2164:1: rule__XAnnotationElementValue__Alternatives : ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) );
+    public final void rule__XAnnotationElementValue__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2168:1: ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) )
+            int alt6=2;
+            alt6 = dfa6.predict(input);
+            switch (alt6) {
+                case 1 :
+                    // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+                    {
+                    // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+                    // InternalOXtype.g:2170:3: ( rule__XAnnotationElementValue__Group_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); 
+                    }
+                    // InternalOXtype.g:2171:3: ( rule__XAnnotationElementValue__Group_0__0 )
+                    // InternalOXtype.g:2171:4: rule__XAnnotationElementValue__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotationElementValue__Group_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2175:2: ( ruleXAnnotationOrExpression )
+                    {
+                    // InternalOXtype.g:2175:2: ( ruleXAnnotationOrExpression )
+                    // InternalOXtype.g:2176:3: ruleXAnnotationOrExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXAnnotationOrExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Alternatives"
+
+
+    // $ANTLR start "rule__XAnnotationOrExpression__Alternatives"
+    // InternalOXtype.g:2185:1: rule__XAnnotationOrExpression__Alternatives : ( ( ruleXAnnotation ) | ( ruleXExpression ) );
+    public final void rule__XAnnotationOrExpression__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2189:1: ( ( ruleXAnnotation ) | ( ruleXExpression ) )
+            int alt7=2;
+            int LA7_0 = input.LA(1);
+
+            if ( (LA7_0==52) ) {
+                alt7=1;
+            }
+            else if ( ((LA7_0>=RULE_ID && LA7_0<=RULE_STRING)||LA7_0==27||(LA7_0>=34 && LA7_0<=35)||LA7_0==40||(LA7_0>=45 && LA7_0<=50)||LA7_0==53||(LA7_0>=57 && LA7_0<=58)||LA7_0==61||LA7_0==63||LA7_0==65||(LA7_0>=69 && LA7_0<=77)||LA7_0==79||LA7_0==88) ) {
+                alt7=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 7, 0, input);
+
+                throw nvae;
+            }
+            switch (alt7) {
+                case 1 :
+                    // InternalOXtype.g:2190:2: ( ruleXAnnotation )
+                    {
+                    // InternalOXtype.g:2190:2: ( ruleXAnnotation )
+                    // InternalOXtype.g:2191:3: ruleXAnnotation
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXAnnotation();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2196:2: ( ruleXExpression )
+                    {
+                    // InternalOXtype.g:2196:2: ( ruleXExpression )
+                    // InternalOXtype.g:2197:3: ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationOrExpression__Alternatives"
+
+
+    // $ANTLR start "rule__XAssignment__Alternatives"
+    // InternalOXtype.g:2206:1: rule__XAssignment__Alternatives : ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) );
+    public final void rule__XAssignment__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2210:1: ( ( ( rule__XAssignment__Group_0__0 ) ) | ( ( rule__XAssignment__Group_1__0 ) ) )
+            int alt8=2;
+            switch ( input.LA(1) ) {
+            case RULE_ID:
+                {
+                int LA8_1 = input.LA(2);
+
+                if ( (LA8_1==13) ) {
+                    alt8=1;
+                }
+                else if ( (LA8_1==EOF||(LA8_1>=RULE_ID && LA8_1<=RULE_STRING)||(LA8_1>=14 && LA8_1<=51)||(LA8_1>=53 && LA8_1<=80)||(LA8_1>=84 && LA8_1<=85)||(LA8_1>=87 && LA8_1<=88)) ) {
+                    alt8=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 8, 1, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 45:
+                {
+                int LA8_2 = input.LA(2);
+
+                if ( (LA8_2==EOF||(LA8_2>=RULE_ID && LA8_2<=RULE_STRING)||(LA8_2>=14 && LA8_2<=51)||(LA8_2>=53 && LA8_2<=80)||(LA8_2>=84 && LA8_2<=85)||(LA8_2>=87 && LA8_2<=88)) ) {
+                    alt8=2;
+                }
+                else if ( (LA8_2==13) ) {
+                    alt8=1;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 8, 2, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 46:
+                {
+                int LA8_3 = input.LA(2);
+
+                if ( (LA8_3==13) ) {
+                    alt8=1;
+                }
+                else if ( (LA8_3==EOF||(LA8_3>=RULE_ID && LA8_3<=RULE_STRING)||(LA8_3>=14 && LA8_3<=51)||(LA8_3>=53 && LA8_3<=80)||(LA8_3>=84 && LA8_3<=85)||(LA8_3>=87 && LA8_3<=88)) ) {
+                    alt8=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 8, 3, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 47:
+                {
+                int LA8_4 = input.LA(2);
+
+                if ( (LA8_4==EOF||(LA8_4>=RULE_ID && LA8_4<=RULE_STRING)||(LA8_4>=14 && LA8_4<=51)||(LA8_4>=53 && LA8_4<=80)||(LA8_4>=84 && LA8_4<=85)||(LA8_4>=87 && LA8_4<=88)) ) {
+                    alt8=2;
+                }
+                else if ( (LA8_4==13) ) {
+                    alt8=1;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 8, 4, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 48:
+                {
+                int LA8_5 = input.LA(2);
+
+                if ( (LA8_5==13) ) {
+                    alt8=1;
+                }
+                else if ( (LA8_5==EOF||(LA8_5>=RULE_ID && LA8_5<=RULE_STRING)||(LA8_5>=14 && LA8_5<=51)||(LA8_5>=53 && LA8_5<=80)||(LA8_5>=84 && LA8_5<=85)||(LA8_5>=87 && LA8_5<=88)) ) {
+                    alt8=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 8, 5, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case RULE_HEX:
+            case RULE_INT:
+            case RULE_DECIMAL:
+            case RULE_STRING:
+            case 27:
+            case 34:
+            case 35:
+            case 40:
+            case 49:
+            case 50:
+            case 53:
+            case 57:
+            case 58:
+            case 61:
+            case 63:
+            case 65:
+            case 69:
+            case 70:
+            case 71:
+            case 72:
+            case 73:
+            case 74:
+            case 75:
+            case 76:
+            case 77:
+            case 79:
+            case 88:
+                {
+                alt8=2;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 8, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt8) {
+                case 1 :
+                    // InternalOXtype.g:2211:2: ( ( rule__XAssignment__Group_0__0 ) )
+                    {
+                    // InternalOXtype.g:2211:2: ( ( rule__XAssignment__Group_0__0 ) )
+                    // InternalOXtype.g:2212:3: ( rule__XAssignment__Group_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAssignmentAccess().getGroup_0()); 
+                    }
+                    // InternalOXtype.g:2213:3: ( rule__XAssignment__Group_0__0 )
+                    // InternalOXtype.g:2213:4: rule__XAssignment__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAssignment__Group_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAssignmentAccess().getGroup_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2217:2: ( ( rule__XAssignment__Group_1__0 ) )
+                    {
+                    // InternalOXtype.g:2217:2: ( ( rule__XAssignment__Group_1__0 ) )
+                    // InternalOXtype.g:2218:3: ( rule__XAssignment__Group_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXAssignmentAccess().getGroup_1()); 
+                    }
+                    // InternalOXtype.g:2219:3: ( rule__XAssignment__Group_1__0 )
+                    // InternalOXtype.g:2219:4: rule__XAssignment__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAssignment__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXAssignmentAccess().getGroup_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Alternatives"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Alternatives"
+    // InternalOXtype.g:2227:1: rule__OpMultiAssign__Alternatives : ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) );
+    public final void rule__OpMultiAssign__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2231:1: ( ( '+=' ) | ( '-=' ) | ( '*=' ) | ( '/=' ) | ( '%=' ) | ( ( rule__OpMultiAssign__Group_5__0 ) ) | ( ( rule__OpMultiAssign__Group_6__0 ) ) )
+            int alt9=7;
+            switch ( input.LA(1) ) {
+            case 16:
+                {
+                alt9=1;
+                }
+                break;
+            case 17:
+                {
+                alt9=2;
+                }
+                break;
+            case 18:
+                {
+                alt9=3;
+                }
+                break;
+            case 19:
+                {
+                alt9=4;
+                }
+                break;
+            case 20:
+                {
+                alt9=5;
+                }
+                break;
+            case 27:
+                {
+                alt9=6;
+                }
+                break;
+            case 26:
+                {
+                alt9=7;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 9, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt9) {
+                case 1 :
+                    // InternalOXtype.g:2232:2: ( '+=' )
+                    {
+                    // InternalOXtype.g:2232:2: ( '+=' )
+                    // InternalOXtype.g:2233:3: '+='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); 
+                    }
+                    match(input,16,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2238:2: ( '-=' )
+                    {
+                    // InternalOXtype.g:2238:2: ( '-=' )
+                    // InternalOXtype.g:2239:3: '-='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); 
+                    }
+                    match(input,17,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2244:2: ( '*=' )
+                    {
+                    // InternalOXtype.g:2244:2: ( '*=' )
+                    // InternalOXtype.g:2245:3: '*='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); 
+                    }
+                    match(input,18,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2250:2: ( '/=' )
+                    {
+                    // InternalOXtype.g:2250:2: ( '/=' )
+                    // InternalOXtype.g:2251:3: '/='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); 
+                    }
+                    match(input,19,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:2256:2: ( '%=' )
+                    {
+                    // InternalOXtype.g:2256:2: ( '%=' )
+                    // InternalOXtype.g:2257:3: '%='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); 
+                    }
+                    match(input,20,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:2262:2: ( ( rule__OpMultiAssign__Group_5__0 ) )
+                    {
+                    // InternalOXtype.g:2262:2: ( ( rule__OpMultiAssign__Group_5__0 ) )
+                    // InternalOXtype.g:2263:3: ( rule__OpMultiAssign__Group_5__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getGroup_5()); 
+                    }
+                    // InternalOXtype.g:2264:3: ( rule__OpMultiAssign__Group_5__0 )
+                    // InternalOXtype.g:2264:4: rule__OpMultiAssign__Group_5__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpMultiAssign__Group_5__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getGroup_5()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:2268:2: ( ( rule__OpMultiAssign__Group_6__0 ) )
+                    {
+                    // InternalOXtype.g:2268:2: ( ( rule__OpMultiAssign__Group_6__0 ) )
+                    // InternalOXtype.g:2269:3: ( rule__OpMultiAssign__Group_6__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAssignAccess().getGroup_6()); 
+                    }
+                    // InternalOXtype.g:2270:3: ( rule__OpMultiAssign__Group_6__0 )
+                    // InternalOXtype.g:2270:4: rule__OpMultiAssign__Group_6__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpMultiAssign__Group_6__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAssignAccess().getGroup_6()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Alternatives"
+
+
+    // $ANTLR start "rule__OpEquality__Alternatives"
+    // InternalOXtype.g:2278:1: rule__OpEquality__Alternatives : ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) );
+    public final void rule__OpEquality__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2282:1: ( ( '==' ) | ( '!=' ) | ( '===' ) | ( '!==' ) )
+            int alt10=4;
+            switch ( input.LA(1) ) {
+            case 21:
+                {
+                alt10=1;
+                }
+                break;
+            case 22:
+                {
+                alt10=2;
+                }
+                break;
+            case 23:
+                {
+                alt10=3;
+                }
+                break;
+            case 24:
+                {
+                alt10=4;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 10, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt10) {
+                case 1 :
+                    // InternalOXtype.g:2283:2: ( '==' )
+                    {
+                    // InternalOXtype.g:2283:2: ( '==' )
+                    // InternalOXtype.g:2284:3: '=='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); 
+                    }
+                    match(input,21,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2289:2: ( '!=' )
+                    {
+                    // InternalOXtype.g:2289:2: ( '!=' )
+                    // InternalOXtype.g:2290:3: '!='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); 
+                    }
+                    match(input,22,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2295:2: ( '===' )
+                    {
+                    // InternalOXtype.g:2295:2: ( '===' )
+                    // InternalOXtype.g:2296:3: '==='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); 
+                    }
+                    match(input,23,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2301:2: ( '!==' )
+                    {
+                    // InternalOXtype.g:2301:2: ( '!==' )
+                    // InternalOXtype.g:2302:3: '!=='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); 
+                    }
+                    match(input,24,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpEquality__Alternatives"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Alternatives_1"
+    // InternalOXtype.g:2311:1: rule__XRelationalExpression__Alternatives_1 : ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) );
+    public final void rule__XRelationalExpression__Alternatives_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2315:1: ( ( ( rule__XRelationalExpression__Group_1_0__0 ) ) | ( ( rule__XRelationalExpression__Group_1_1__0 ) ) )
+            int alt11=2;
+            int LA11_0 = input.LA(1);
+
+            if ( (LA11_0==59) ) {
+                alt11=1;
+            }
+            else if ( ((LA11_0>=25 && LA11_0<=27)) ) {
+                alt11=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 11, 0, input);
+
+                throw nvae;
+            }
+            switch (alt11) {
+                case 1 :
+                    // InternalOXtype.g:2316:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) )
+                    {
+                    // InternalOXtype.g:2316:2: ( ( rule__XRelationalExpression__Group_1_0__0 ) )
+                    // InternalOXtype.g:2317:3: ( rule__XRelationalExpression__Group_1_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); 
+                    }
+                    // InternalOXtype.g:2318:3: ( rule__XRelationalExpression__Group_1_0__0 )
+                    // InternalOXtype.g:2318:4: rule__XRelationalExpression__Group_1_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XRelationalExpression__Group_1_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2322:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) )
+                    {
+                    // InternalOXtype.g:2322:2: ( ( rule__XRelationalExpression__Group_1_1__0 ) )
+                    // InternalOXtype.g:2323:3: ( rule__XRelationalExpression__Group_1_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); 
+                    }
+                    // InternalOXtype.g:2324:3: ( rule__XRelationalExpression__Group_1_1__0 )
+                    // InternalOXtype.g:2324:4: rule__XRelationalExpression__Group_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XRelationalExpression__Group_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Alternatives_1"
+
+
+    // $ANTLR start "rule__OpCompare__Alternatives"
+    // InternalOXtype.g:2332:1: rule__OpCompare__Alternatives : ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) );
+    public final void rule__OpCompare__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2336:1: ( ( '>=' ) | ( ( rule__OpCompare__Group_1__0 ) ) | ( '>' ) | ( '<' ) )
+            int alt12=4;
+            switch ( input.LA(1) ) {
+            case 25:
+                {
+                alt12=1;
+                }
+                break;
+            case 27:
+                {
+                int LA12_2 = input.LA(2);
+
+                if ( (LA12_2==13) ) {
+                    alt12=2;
+                }
+                else if ( (LA12_2==EOF||(LA12_2>=RULE_ID && LA12_2<=RULE_STRING)||LA12_2==27||(LA12_2>=34 && LA12_2<=35)||LA12_2==40||(LA12_2>=45 && LA12_2<=50)||LA12_2==53||(LA12_2>=57 && LA12_2<=58)||LA12_2==61||LA12_2==63||LA12_2==65||(LA12_2>=69 && LA12_2<=77)||LA12_2==79||LA12_2==88) ) {
+                    alt12=4;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 12, 2, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 26:
+                {
+                alt12=3;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 12, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt12) {
+                case 1 :
+                    // InternalOXtype.g:2337:2: ( '>=' )
+                    {
+                    // InternalOXtype.g:2337:2: ( '>=' )
+                    // InternalOXtype.g:2338:3: '>='
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); 
+                    }
+                    match(input,25,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2343:2: ( ( rule__OpCompare__Group_1__0 ) )
+                    {
+                    // InternalOXtype.g:2343:2: ( ( rule__OpCompare__Group_1__0 ) )
+                    // InternalOXtype.g:2344:3: ( rule__OpCompare__Group_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpCompareAccess().getGroup_1()); 
+                    }
+                    // InternalOXtype.g:2345:3: ( rule__OpCompare__Group_1__0 )
+                    // InternalOXtype.g:2345:4: rule__OpCompare__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpCompare__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpCompareAccess().getGroup_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2349:2: ( '>' )
+                    {
+                    // InternalOXtype.g:2349:2: ( '>' )
+                    // InternalOXtype.g:2350:3: '>'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); 
+                    }
+                    match(input,26,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2355:2: ( '<' )
+                    {
+                    // InternalOXtype.g:2355:2: ( '<' )
+                    // InternalOXtype.g:2356:3: '<'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); 
+                    }
+                    match(input,27,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpCompare__Alternatives"
+
+
+    // $ANTLR start "rule__OpOther__Alternatives"
+    // InternalOXtype.g:2365:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );
+    public final void rule__OpOther__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2369:1: ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) )
+            int alt13=9;
+            alt13 = dfa13.predict(input);
+            switch (alt13) {
+                case 1 :
+                    // InternalOXtype.g:2370:2: ( '->' )
+                    {
+                    // InternalOXtype.g:2370:2: ( '->' )
+                    // InternalOXtype.g:2371:3: '->'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); 
+                    }
+                    match(input,28,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2376:2: ( '..<' )
+                    {
+                    // InternalOXtype.g:2376:2: ( '..<' )
+                    // InternalOXtype.g:2377:3: '..<'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); 
+                    }
+                    match(input,29,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2382:2: ( ( rule__OpOther__Group_2__0 ) )
+                    {
+                    // InternalOXtype.g:2382:2: ( ( rule__OpOther__Group_2__0 ) )
+                    // InternalOXtype.g:2383:3: ( rule__OpOther__Group_2__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getGroup_2()); 
+                    }
+                    // InternalOXtype.g:2384:3: ( rule__OpOther__Group_2__0 )
+                    // InternalOXtype.g:2384:4: rule__OpOther__Group_2__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpOther__Group_2__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getGroup_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2388:2: ( '..' )
+                    {
+                    // InternalOXtype.g:2388:2: ( '..' )
+                    // InternalOXtype.g:2389:3: '..'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); 
+                    }
+                    match(input,30,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:2394:2: ( '=>' )
+                    {
+                    // InternalOXtype.g:2394:2: ( '=>' )
+                    // InternalOXtype.g:2395:3: '=>'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); 
+                    }
+                    match(input,31,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:2400:2: ( ( rule__OpOther__Group_5__0 ) )
+                    {
+                    // InternalOXtype.g:2400:2: ( ( rule__OpOther__Group_5__0 ) )
+                    // InternalOXtype.g:2401:3: ( rule__OpOther__Group_5__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getGroup_5()); 
+                    }
+                    // InternalOXtype.g:2402:3: ( rule__OpOther__Group_5__0 )
+                    // InternalOXtype.g:2402:4: rule__OpOther__Group_5__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpOther__Group_5__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getGroup_5()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:2406:2: ( ( rule__OpOther__Group_6__0 ) )
+                    {
+                    // InternalOXtype.g:2406:2: ( ( rule__OpOther__Group_6__0 ) )
+                    // InternalOXtype.g:2407:3: ( rule__OpOther__Group_6__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getGroup_6()); 
+                    }
+                    // InternalOXtype.g:2408:3: ( rule__OpOther__Group_6__0 )
+                    // InternalOXtype.g:2408:4: rule__OpOther__Group_6__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpOther__Group_6__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getGroup_6()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 8 :
+                    // InternalOXtype.g:2412:2: ( '<>' )
+                    {
+                    // InternalOXtype.g:2412:2: ( '<>' )
+                    // InternalOXtype.g:2413:3: '<>'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); 
+                    }
+                    match(input,32,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 9 :
+                    // InternalOXtype.g:2418:2: ( '?:' )
+                    {
+                    // InternalOXtype.g:2418:2: ( '?:' )
+                    // InternalOXtype.g:2419:3: '?:'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); 
+                    }
+                    match(input,33,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Alternatives"
+
+
+    // $ANTLR start "rule__OpOther__Alternatives_5_1"
+    // InternalOXtype.g:2428:1: rule__OpOther__Alternatives_5_1 : ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) );
+    public final void rule__OpOther__Alternatives_5_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2432:1: ( ( ( rule__OpOther__Group_5_1_0__0 ) ) | ( '>' ) )
+            int alt14=2;
+            int LA14_0 = input.LA(1);
+
+            if ( (LA14_0==26) ) {
+                int LA14_1 = input.LA(2);
+
+                if ( (LA14_1==26) ) {
+                    alt14=1;
+                }
+                else if ( (LA14_1==EOF||(LA14_1>=RULE_ID && LA14_1<=RULE_STRING)||LA14_1==27||(LA14_1>=34 && LA14_1<=35)||LA14_1==40||(LA14_1>=45 && LA14_1<=50)||LA14_1==53||(LA14_1>=57 && LA14_1<=58)||LA14_1==61||LA14_1==63||LA14_1==65||(LA14_1>=69 && LA14_1<=77)||LA14_1==79||LA14_1==88) ) {
+                    alt14=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 14, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 14, 0, input);
+
+                throw nvae;
+            }
+            switch (alt14) {
+                case 1 :
+                    // InternalOXtype.g:2433:2: ( ( rule__OpOther__Group_5_1_0__0 ) )
+                    {
+                    // InternalOXtype.g:2433:2: ( ( rule__OpOther__Group_5_1_0__0 ) )
+                    // InternalOXtype.g:2434:3: ( rule__OpOther__Group_5_1_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); 
+                    }
+                    // InternalOXtype.g:2435:3: ( rule__OpOther__Group_5_1_0__0 )
+                    // InternalOXtype.g:2435:4: rule__OpOther__Group_5_1_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpOther__Group_5_1_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getGroup_5_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2439:2: ( '>' )
+                    {
+                    // InternalOXtype.g:2439:2: ( '>' )
+                    // InternalOXtype.g:2440:3: '>'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); 
+                    }
+                    match(input,26,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Alternatives_5_1"
+
+
+    // $ANTLR start "rule__OpOther__Alternatives_6_1"
+    // InternalOXtype.g:2449:1: rule__OpOther__Alternatives_6_1 : ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) );
+    public final void rule__OpOther__Alternatives_6_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2453:1: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) | ( '<' ) | ( '=>' ) )
+            int alt15=3;
+            int LA15_0 = input.LA(1);
+
+            if ( (LA15_0==27) ) {
+                int LA15_1 = input.LA(2);
+
+                if ( (synpred33_InternalOXtype()) ) {
+                    alt15=1;
+                }
+                else if ( (synpred34_InternalOXtype()) ) {
+                    alt15=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 15, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else if ( (LA15_0==31) ) {
+                alt15=3;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 15, 0, input);
+
+                throw nvae;
+            }
+            switch (alt15) {
+                case 1 :
+                    // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+                    {
+                    // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+                    // InternalOXtype.g:2455:3: ( rule__OpOther__Group_6_1_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); 
+                    }
+                    // InternalOXtype.g:2456:3: ( rule__OpOther__Group_6_1_0__0 )
+                    // InternalOXtype.g:2456:4: rule__OpOther__Group_6_1_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__OpOther__Group_6_1_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2460:2: ( '<' )
+                    {
+                    // InternalOXtype.g:2460:2: ( '<' )
+                    // InternalOXtype.g:2461:3: '<'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); 
+                    }
+                    match(input,27,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2466:2: ( '=>' )
+                    {
+                    // InternalOXtype.g:2466:2: ( '=>' )
+                    // InternalOXtype.g:2467:3: '=>'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); 
+                    }
+                    match(input,31,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Alternatives_6_1"
+
+
+    // $ANTLR start "rule__OpAdd__Alternatives"
+    // InternalOXtype.g:2476:1: rule__OpAdd__Alternatives : ( ( '+' ) | ( '-' ) );
+    public final void rule__OpAdd__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2480:1: ( ( '+' ) | ( '-' ) )
+            int alt16=2;
+            int LA16_0 = input.LA(1);
+
+            if ( (LA16_0==34) ) {
+                alt16=1;
+            }
+            else if ( (LA16_0==35) ) {
+                alt16=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 16, 0, input);
+
+                throw nvae;
+            }
+            switch (alt16) {
+                case 1 :
+                    // InternalOXtype.g:2481:2: ( '+' )
+                    {
+                    // InternalOXtype.g:2481:2: ( '+' )
+                    // InternalOXtype.g:2482:3: '+'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); 
+                    }
+                    match(input,34,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpAddAccess().getPlusSignKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2487:2: ( '-' )
+                    {
+                    // InternalOXtype.g:2487:2: ( '-' )
+                    // InternalOXtype.g:2488:3: '-'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); 
+                    }
+                    match(input,35,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpAdd__Alternatives"
+
+
+    // $ANTLR start "rule__OpMulti__Alternatives"
+    // InternalOXtype.g:2497:1: rule__OpMulti__Alternatives : ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) );
+    public final void rule__OpMulti__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2501:1: ( ( '*' ) | ( '**' ) | ( '/' ) | ( '%' ) )
+            int alt17=4;
+            switch ( input.LA(1) ) {
+            case 36:
+                {
+                alt17=1;
+                }
+                break;
+            case 37:
+                {
+                alt17=2;
+                }
+                break;
+            case 38:
+                {
+                alt17=3;
+                }
+                break;
+            case 39:
+                {
+                alt17=4;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 17, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt17) {
+                case 1 :
+                    // InternalOXtype.g:2502:2: ( '*' )
+                    {
+                    // InternalOXtype.g:2502:2: ( '*' )
+                    // InternalOXtype.g:2503:3: '*'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); 
+                    }
+                    match(input,36,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAccess().getAsteriskKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2508:2: ( '**' )
+                    {
+                    // InternalOXtype.g:2508:2: ( '**' )
+                    // InternalOXtype.g:2509:3: '**'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); 
+                    }
+                    match(input,37,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2514:2: ( '/' )
+                    {
+                    // InternalOXtype.g:2514:2: ( '/' )
+                    // InternalOXtype.g:2515:3: '/'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); 
+                    }
+                    match(input,38,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAccess().getSolidusKeyword_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2520:2: ( '%' )
+                    {
+                    // InternalOXtype.g:2520:2: ( '%' )
+                    // InternalOXtype.g:2521:3: '%'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); 
+                    }
+                    match(input,39,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpMultiAccess().getPercentSignKeyword_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMulti__Alternatives"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Alternatives"
+    // InternalOXtype.g:2530:1: rule__XUnaryOperation__Alternatives : ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) );
+    public final void rule__XUnaryOperation__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2534:1: ( ( ( rule__XUnaryOperation__Group_0__0 ) ) | ( ruleXCastedExpression ) )
+            int alt18=2;
+            int LA18_0 = input.LA(1);
+
+            if ( ((LA18_0>=34 && LA18_0<=35)||LA18_0==40) ) {
+                alt18=1;
+            }
+            else if ( ((LA18_0>=RULE_ID && LA18_0<=RULE_STRING)||LA18_0==27||(LA18_0>=45 && LA18_0<=50)||LA18_0==53||(LA18_0>=57 && LA18_0<=58)||LA18_0==61||LA18_0==63||LA18_0==65||(LA18_0>=69 && LA18_0<=77)||LA18_0==79||LA18_0==88) ) {
+                alt18=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 18, 0, input);
+
+                throw nvae;
+            }
+            switch (alt18) {
+                case 1 :
+                    // InternalOXtype.g:2535:2: ( ( rule__XUnaryOperation__Group_0__0 ) )
+                    {
+                    // InternalOXtype.g:2535:2: ( ( rule__XUnaryOperation__Group_0__0 ) )
+                    // InternalOXtype.g:2536:3: ( rule__XUnaryOperation__Group_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXUnaryOperationAccess().getGroup_0()); 
+                    }
+                    // InternalOXtype.g:2537:3: ( rule__XUnaryOperation__Group_0__0 )
+                    // InternalOXtype.g:2537:4: rule__XUnaryOperation__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XUnaryOperation__Group_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXUnaryOperationAccess().getGroup_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2541:2: ( ruleXCastedExpression )
+                    {
+                    // InternalOXtype.g:2541:2: ( ruleXCastedExpression )
+                    // InternalOXtype.g:2542:3: ruleXCastedExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXCastedExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Alternatives"
+
+
+    // $ANTLR start "rule__OpUnary__Alternatives"
+    // InternalOXtype.g:2551:1: rule__OpUnary__Alternatives : ( ( '!' ) | ( '-' ) | ( '+' ) );
+    public final void rule__OpUnary__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2555:1: ( ( '!' ) | ( '-' ) | ( '+' ) )
+            int alt19=3;
+            switch ( input.LA(1) ) {
+            case 40:
+                {
+                alt19=1;
+                }
+                break;
+            case 35:
+                {
+                alt19=2;
+                }
+                break;
+            case 34:
+                {
+                alt19=3;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 19, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt19) {
+                case 1 :
+                    // InternalOXtype.g:2556:2: ( '!' )
+                    {
+                    // InternalOXtype.g:2556:2: ( '!' )
+                    // InternalOXtype.g:2557:3: '!'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); 
+                    }
+                    match(input,40,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2562:2: ( '-' )
+                    {
+                    // InternalOXtype.g:2562:2: ( '-' )
+                    // InternalOXtype.g:2563:3: '-'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); 
+                    }
+                    match(input,35,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2568:2: ( '+' )
+                    {
+                    // InternalOXtype.g:2568:2: ( '+' )
+                    // InternalOXtype.g:2569:3: '+'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); 
+                    }
+                    match(input,34,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpUnary__Alternatives"
+
+
+    // $ANTLR start "rule__OpPostfix__Alternatives"
+    // InternalOXtype.g:2578:1: rule__OpPostfix__Alternatives : ( ( '++' ) | ( '--' ) );
+    public final void rule__OpPostfix__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2582:1: ( ( '++' ) | ( '--' ) )
+            int alt20=2;
+            int LA20_0 = input.LA(1);
+
+            if ( (LA20_0==41) ) {
+                alt20=1;
+            }
+            else if ( (LA20_0==42) ) {
+                alt20=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 20, 0, input);
+
+                throw nvae;
+            }
+            switch (alt20) {
+                case 1 :
+                    // InternalOXtype.g:2583:2: ( '++' )
+                    {
+                    // InternalOXtype.g:2583:2: ( '++' )
+                    // InternalOXtype.g:2584:3: '++'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); 
+                    }
+                    match(input,41,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2589:2: ( '--' )
+                    {
+                    // InternalOXtype.g:2589:2: ( '--' )
+                    // InternalOXtype.g:2590:3: '--'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); 
+                    }
+                    match(input,42,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpPostfix__Alternatives"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1"
+    // InternalOXtype.g:2599:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );
+    public final void rule__XMemberFeatureCall__Alternatives_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2603:1: ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) )
+            int alt21=2;
+            alt21 = dfa21.predict(input);
+            switch (alt21) {
+                case 1 :
+                    // InternalOXtype.g:2604:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) )
+                    {
+                    // InternalOXtype.g:2604:2: ( ( rule__XMemberFeatureCall__Group_1_0__0 ) )
+                    // InternalOXtype.g:2605:3: ( rule__XMemberFeatureCall__Group_1_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); 
+                    }
+                    // InternalOXtype.g:2606:3: ( rule__XMemberFeatureCall__Group_1_0__0 )
+                    // InternalOXtype.g:2606:4: rule__XMemberFeatureCall__Group_1_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__Group_1_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2610:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) )
+                    {
+                    // InternalOXtype.g:2610:2: ( ( rule__XMemberFeatureCall__Group_1_1__0 ) )
+                    // InternalOXtype.g:2611:3: ( rule__XMemberFeatureCall__Group_1_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); 
+                    }
+                    // InternalOXtype.g:2612:3: ( rule__XMemberFeatureCall__Group_1_1__0 )
+                    // InternalOXtype.g:2612:4: rule__XMemberFeatureCall__Group_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__Group_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"
+    // InternalOXtype.g:2620:1: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) );
+    public final void rule__XMemberFeatureCall__Alternatives_1_0_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2624:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) ) )
+            int alt22=2;
+            int LA22_0 = input.LA(1);
+
+            if ( (LA22_0==43) ) {
+                alt22=1;
+            }
+            else if ( (LA22_0==84) ) {
+                alt22=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 22, 0, input);
+
+                throw nvae;
+            }
+            switch (alt22) {
+                case 1 :
+                    // InternalOXtype.g:2625:2: ( '.' )
+                    {
+                    // InternalOXtype.g:2625:2: ( '.' )
+                    // InternalOXtype.g:2626:3: '.'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); 
+                    }
+                    match(input,43,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2631:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) )
+                    {
+                    // InternalOXtype.g:2631:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 ) )
+                    // InternalOXtype.g:2632:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); 
+                    }
+                    // InternalOXtype.g:2633:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 )
+                    // InternalOXtype.g:2633:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_0_0_0_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_0_0_0_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"
+    // InternalOXtype.g:2641:1: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 : ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) );
+    public final void rule__XMemberFeatureCall__Alternatives_1_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2645:1: ( ( '.' ) | ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) ) | ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) ) )
+            int alt23=3;
+            switch ( input.LA(1) ) {
+            case 43:
+                {
+                alt23=1;
+                }
+                break;
+            case 85:
+                {
+                alt23=2;
+                }
+                break;
+            case 84:
+                {
+                alt23=3;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 23, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt23) {
+                case 1 :
+                    // InternalOXtype.g:2646:2: ( '.' )
+                    {
+                    // InternalOXtype.g:2646:2: ( '.' )
+                    // InternalOXtype.g:2647:3: '.'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); 
+                    }
+                    match(input,43,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2652:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) )
+                    {
+                    // InternalOXtype.g:2652:2: ( ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 ) )
+                    // InternalOXtype.g:2653:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); 
+                    }
+                    // InternalOXtype.g:2654:3: ( rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 )
+                    // InternalOXtype.g:2654:4: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeAssignment_1_1_0_0_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2658:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) )
+                    {
+                    // InternalOXtype.g:2658:2: ( ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 ) )
+                    // InternalOXtype.g:2659:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); 
+                    }
+                    // InternalOXtype.g:2660:3: ( rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 )
+                    // InternalOXtype.g:2660:4: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticAssignment_1_1_0_0_1_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_0_0_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Alternatives_1_1_3_1"
+    // InternalOXtype.g:2668:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );
+    public final void rule__XMemberFeatureCall__Alternatives_1_1_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2672:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) )
+            int alt24=2;
+            alt24 = dfa24.predict(input);
+            switch (alt24) {
+                case 1 :
+                    // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+                    {
+                    // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+                    // InternalOXtype.g:2674:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); 
+                    }
+                    // InternalOXtype.g:2675:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+                    // InternalOXtype.g:2675:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2679:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) )
+                    {
+                    // InternalOXtype.g:2679:2: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) )
+                    // InternalOXtype.g:2680:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); 
+                    }
+                    // InternalOXtype.g:2681:3: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 )
+                    // InternalOXtype.g:2681:4: rule__XMemberFeatureCall__Group_1_1_3_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__Group_1_1_3_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Alternatives_1_1_3_1"
+
+
+    // $ANTLR start "rule__XPrimaryExpression__Alternatives"
+    // InternalOXtype.g:2689:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );
+    public final void rule__XPrimaryExpression__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2693:1: ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) )
+            int alt25=15;
+            alt25 = dfa25.predict(input);
+            switch (alt25) {
+                case 1 :
+                    // InternalOXtype.g:2694:2: ( ruleXConstructorCall )
+                    {
+                    // InternalOXtype.g:2694:2: ( ruleXConstructorCall )
+                    // InternalOXtype.g:2695:3: ruleXConstructorCall
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXConstructorCall();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2700:2: ( ruleXBlockExpression )
+                    {
+                    // InternalOXtype.g:2700:2: ( ruleXBlockExpression )
+                    // InternalOXtype.g:2701:3: ruleXBlockExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXBlockExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2706:2: ( ruleXSwitchExpression )
+                    {
+                    // InternalOXtype.g:2706:2: ( ruleXSwitchExpression )
+                    // InternalOXtype.g:2707:3: ruleXSwitchExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXSwitchExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2712:2: ( ( ruleXSynchronizedExpression ) )
+                    {
+                    // InternalOXtype.g:2712:2: ( ( ruleXSynchronizedExpression ) )
+                    // InternalOXtype.g:2713:3: ( ruleXSynchronizedExpression )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); 
+                    }
+                    // InternalOXtype.g:2714:3: ( ruleXSynchronizedExpression )
+                    // InternalOXtype.g:2714:4: ruleXSynchronizedExpression
+                    {
+                    pushFollow(FOLLOW_2);
+                    ruleXSynchronizedExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:2718:2: ( ruleXFeatureCall )
+                    {
+                    // InternalOXtype.g:2718:2: ( ruleXFeatureCall )
+                    // InternalOXtype.g:2719:3: ruleXFeatureCall
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXFeatureCall();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:2724:2: ( ruleXLiteral )
+                    {
+                    // InternalOXtype.g:2724:2: ( ruleXLiteral )
+                    // InternalOXtype.g:2725:3: ruleXLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:2730:2: ( ruleXIfExpression )
+                    {
+                    // InternalOXtype.g:2730:2: ( ruleXIfExpression )
+                    // InternalOXtype.g:2731:3: ruleXIfExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXIfExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 8 :
+                    // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+                    {
+                    // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+                    // InternalOXtype.g:2737:3: ( ruleXForLoopExpression )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); 
+                    }
+                    // InternalOXtype.g:2738:3: ( ruleXForLoopExpression )
+                    // InternalOXtype.g:2738:4: ruleXForLoopExpression
+                    {
+                    pushFollow(FOLLOW_2);
+                    ruleXForLoopExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 9 :
+                    // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+                    {
+                    // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+                    // InternalOXtype.g:2743:3: ruleXBasicForLoopExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXBasicForLoopExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 10 :
+                    // InternalOXtype.g:2748:2: ( ruleXWhileExpression )
+                    {
+                    // InternalOXtype.g:2748:2: ( ruleXWhileExpression )
+                    // InternalOXtype.g:2749:3: ruleXWhileExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXWhileExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 11 :
+                    // InternalOXtype.g:2754:2: ( ruleXDoWhileExpression )
+                    {
+                    // InternalOXtype.g:2754:2: ( ruleXDoWhileExpression )
+                    // InternalOXtype.g:2755:3: ruleXDoWhileExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXDoWhileExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 12 :
+                    // InternalOXtype.g:2760:2: ( ruleXThrowExpression )
+                    {
+                    // InternalOXtype.g:2760:2: ( ruleXThrowExpression )
+                    // InternalOXtype.g:2761:3: ruleXThrowExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXThrowExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 13 :
+                    // InternalOXtype.g:2766:2: ( ruleXReturnExpression )
+                    {
+                    // InternalOXtype.g:2766:2: ( ruleXReturnExpression )
+                    // InternalOXtype.g:2767:3: ruleXReturnExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXReturnExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 14 :
+                    // InternalOXtype.g:2772:2: ( ruleXTryCatchFinallyExpression )
+                    {
+                    // InternalOXtype.g:2772:2: ( ruleXTryCatchFinallyExpression )
+                    // InternalOXtype.g:2773:3: ruleXTryCatchFinallyExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXTryCatchFinallyExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 15 :
+                    // InternalOXtype.g:2778:2: ( ruleXParenthesizedExpression )
+                    {
+                    // InternalOXtype.g:2778:2: ( ruleXParenthesizedExpression )
+                    // InternalOXtype.g:2779:3: ruleXParenthesizedExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXParenthesizedExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPrimaryExpression__Alternatives"
+
+
+    // $ANTLR start "rule__XLiteral__Alternatives"
+    // InternalOXtype.g:2788:1: rule__XLiteral__Alternatives : ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) );
+    public final void rule__XLiteral__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2792:1: ( ( ruleXCollectionLiteral ) | ( ( ruleXClosure ) ) | ( ruleXBooleanLiteral ) | ( ruleXNumberLiteral ) | ( ruleXNullLiteral ) | ( ruleXStringLiteral ) | ( ruleXTypeLiteral ) )
+            int alt26=7;
+            switch ( input.LA(1) ) {
+            case 57:
+                {
+                alt26=1;
+                }
+                break;
+            case 58:
+                {
+                alt26=2;
+                }
+                break;
+            case 50:
+            case 88:
+                {
+                alt26=3;
+                }
+                break;
+            case RULE_HEX:
+            case RULE_INT:
+            case RULE_DECIMAL:
+                {
+                alt26=4;
+                }
+                break;
+            case 73:
+                {
+                alt26=5;
+                }
+                break;
+            case RULE_STRING:
+                {
+                alt26=6;
+                }
+                break;
+            case 74:
+                {
+                alt26=7;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 26, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt26) {
+                case 1 :
+                    // InternalOXtype.g:2793:2: ( ruleXCollectionLiteral )
+                    {
+                    // InternalOXtype.g:2793:2: ( ruleXCollectionLiteral )
+                    // InternalOXtype.g:2794:3: ruleXCollectionLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXCollectionLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2799:2: ( ( ruleXClosure ) )
+                    {
+                    // InternalOXtype.g:2799:2: ( ( ruleXClosure ) )
+                    // InternalOXtype.g:2800:3: ( ruleXClosure )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); 
+                    }
+                    // InternalOXtype.g:2801:3: ( ruleXClosure )
+                    // InternalOXtype.g:2801:4: ruleXClosure
+                    {
+                    pushFollow(FOLLOW_2);
+                    ruleXClosure();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2805:2: ( ruleXBooleanLiteral )
+                    {
+                    // InternalOXtype.g:2805:2: ( ruleXBooleanLiteral )
+                    // InternalOXtype.g:2806:3: ruleXBooleanLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXBooleanLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2811:2: ( ruleXNumberLiteral )
+                    {
+                    // InternalOXtype.g:2811:2: ( ruleXNumberLiteral )
+                    // InternalOXtype.g:2812:3: ruleXNumberLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXNumberLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:2817:2: ( ruleXNullLiteral )
+                    {
+                    // InternalOXtype.g:2817:2: ( ruleXNullLiteral )
+                    // InternalOXtype.g:2818:3: ruleXNullLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXNullLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:2823:2: ( ruleXStringLiteral )
+                    {
+                    // InternalOXtype.g:2823:2: ( ruleXStringLiteral )
+                    // InternalOXtype.g:2824:3: ruleXStringLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXStringLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:2829:2: ( ruleXTypeLiteral )
+                    {
+                    // InternalOXtype.g:2829:2: ( ruleXTypeLiteral )
+                    // InternalOXtype.g:2830:3: ruleXTypeLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXTypeLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XLiteral__Alternatives"
+
+
+    // $ANTLR start "rule__XCollectionLiteral__Alternatives"
+    // InternalOXtype.g:2839:1: rule__XCollectionLiteral__Alternatives : ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) );
+    public final void rule__XCollectionLiteral__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2843:1: ( ( ruleXSetLiteral ) | ( ruleXListLiteral ) )
+            int alt27=2;
+            int LA27_0 = input.LA(1);
+
+            if ( (LA27_0==57) ) {
+                int LA27_1 = input.LA(2);
+
+                if ( (LA27_1==61) ) {
+                    alt27=1;
+                }
+                else if ( (LA27_1==58) ) {
+                    alt27=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 27, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 27, 0, input);
+
+                throw nvae;
+            }
+            switch (alt27) {
+                case 1 :
+                    // InternalOXtype.g:2844:2: ( ruleXSetLiteral )
+                    {
+                    // InternalOXtype.g:2844:2: ( ruleXSetLiteral )
+                    // InternalOXtype.g:2845:3: ruleXSetLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXSetLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2850:2: ( ruleXListLiteral )
+                    {
+                    // InternalOXtype.g:2850:2: ( ruleXListLiteral )
+                    // InternalOXtype.g:2851:3: ruleXListLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXListLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCollectionLiteral__Alternatives"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Alternatives_2"
+    // InternalOXtype.g:2860:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );
+    public final void rule__XSwitchExpression__Alternatives_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2864:1: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) )
+            int alt28=2;
+            alt28 = dfa28.predict(input);
+            switch (alt28) {
+                case 1 :
+                    // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+                    {
+                    // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+                    // InternalOXtype.g:2866:3: ( rule__XSwitchExpression__Group_2_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); 
+                    }
+                    // InternalOXtype.g:2867:3: ( rule__XSwitchExpression__Group_2_0__0 )
+                    // InternalOXtype.g:2867:4: rule__XSwitchExpression__Group_2_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XSwitchExpression__Group_2_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2871:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) )
+                    {
+                    // InternalOXtype.g:2871:2: ( ( rule__XSwitchExpression__Group_2_1__0 ) )
+                    // InternalOXtype.g:2872:3: ( rule__XSwitchExpression__Group_2_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); 
+                    }
+                    // InternalOXtype.g:2873:3: ( rule__XSwitchExpression__Group_2_1__0 )
+                    // InternalOXtype.g:2873:4: rule__XSwitchExpression__Group_2_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XSwitchExpression__Group_2_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Alternatives_2"
+
+
+    // $ANTLR start "rule__XCasePart__Alternatives_3"
+    // InternalOXtype.g:2881:1: rule__XCasePart__Alternatives_3 : ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) );
+    public final void rule__XCasePart__Alternatives_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2885:1: ( ( ( rule__XCasePart__Group_3_0__0 ) ) | ( ( rule__XCasePart__FallThroughAssignment_3_1 ) ) )
+            int alt29=2;
+            int LA29_0 = input.LA(1);
+
+            if ( (LA29_0==66) ) {
+                alt29=1;
+            }
+            else if ( (LA29_0==55) ) {
+                alt29=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 29, 0, input);
+
+                throw nvae;
+            }
+            switch (alt29) {
+                case 1 :
+                    // InternalOXtype.g:2886:2: ( ( rule__XCasePart__Group_3_0__0 ) )
+                    {
+                    // InternalOXtype.g:2886:2: ( ( rule__XCasePart__Group_3_0__0 ) )
+                    // InternalOXtype.g:2887:3: ( rule__XCasePart__Group_3_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXCasePartAccess().getGroup_3_0()); 
+                    }
+                    // InternalOXtype.g:2888:3: ( rule__XCasePart__Group_3_0__0 )
+                    // InternalOXtype.g:2888:4: rule__XCasePart__Group_3_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XCasePart__Group_3_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXCasePartAccess().getGroup_3_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2892:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) )
+                    {
+                    // InternalOXtype.g:2892:2: ( ( rule__XCasePart__FallThroughAssignment_3_1 ) )
+                    // InternalOXtype.g:2893:3: ( rule__XCasePart__FallThroughAssignment_3_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); 
+                    }
+                    // InternalOXtype.g:2894:3: ( rule__XCasePart__FallThroughAssignment_3_1 )
+                    // InternalOXtype.g:2894:4: rule__XCasePart__FallThroughAssignment_3_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XCasePart__FallThroughAssignment_3_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXCasePartAccess().getFallThroughAssignment_3_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Alternatives_3"
+
+
+    // $ANTLR start "rule__XExpressionOrVarDeclaration__Alternatives"
+    // InternalOXtype.g:2902:1: rule__XExpressionOrVarDeclaration__Alternatives : ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) );
+    public final void rule__XExpressionOrVarDeclaration__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2906:1: ( ( ruleXVariableDeclaration ) | ( ruleXExpression ) )
+            int alt30=2;
+            int LA30_0 = input.LA(1);
+
+            if ( (LA30_0==44||LA30_0==87) ) {
+                alt30=1;
+            }
+            else if ( ((LA30_0>=RULE_ID && LA30_0<=RULE_STRING)||LA30_0==27||(LA30_0>=34 && LA30_0<=35)||LA30_0==40||(LA30_0>=45 && LA30_0<=50)||LA30_0==53||(LA30_0>=57 && LA30_0<=58)||LA30_0==61||LA30_0==63||LA30_0==65||(LA30_0>=69 && LA30_0<=77)||LA30_0==79||LA30_0==88) ) {
+                alt30=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 30, 0, input);
+
+                throw nvae;
+            }
+            switch (alt30) {
+                case 1 :
+                    // InternalOXtype.g:2907:2: ( ruleXVariableDeclaration )
+                    {
+                    // InternalOXtype.g:2907:2: ( ruleXVariableDeclaration )
+                    // InternalOXtype.g:2908:3: ruleXVariableDeclaration
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXVariableDeclaration();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2913:2: ( ruleXExpression )
+                    {
+                    // InternalOXtype.g:2913:2: ( ruleXExpression )
+                    // InternalOXtype.g:2914:3: ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionOrVarDeclaration__Alternatives"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Alternatives_1"
+    // InternalOXtype.g:2923:1: rule__XVariableDeclaration__Alternatives_1 : ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) );
+    public final void rule__XVariableDeclaration__Alternatives_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2927:1: ( ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) ) | ( 'val' ) )
+            int alt31=2;
+            int LA31_0 = input.LA(1);
+
+            if ( (LA31_0==87) ) {
+                alt31=1;
+            }
+            else if ( (LA31_0==44) ) {
+                alt31=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 31, 0, input);
+
+                throw nvae;
+            }
+            switch (alt31) {
+                case 1 :
+                    // InternalOXtype.g:2928:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) )
+                    {
+                    // InternalOXtype.g:2928:2: ( ( rule__XVariableDeclaration__WriteableAssignment_1_0 ) )
+                    // InternalOXtype.g:2929:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); 
+                    }
+                    // InternalOXtype.g:2930:3: ( rule__XVariableDeclaration__WriteableAssignment_1_0 )
+                    // InternalOXtype.g:2930:4: rule__XVariableDeclaration__WriteableAssignment_1_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XVariableDeclaration__WriteableAssignment_1_0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXVariableDeclarationAccess().getWriteableAssignment_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2934:2: ( 'val' )
+                    {
+                    // InternalOXtype.g:2934:2: ( 'val' )
+                    // InternalOXtype.g:2935:3: 'val'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); 
+                    }
+                    match(input,44,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Alternatives_1"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Alternatives_2"
+    // InternalOXtype.g:2944:1: rule__XVariableDeclaration__Alternatives_2 : ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) );
+    public final void rule__XVariableDeclaration__Alternatives_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2948:1: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) | ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) ) )
+            int alt32=2;
+            int LA32_0 = input.LA(1);
+
+            if ( (LA32_0==RULE_ID) ) {
+                int LA32_1 = input.LA(2);
+
+                if ( (synpred73_InternalOXtype()) ) {
+                    alt32=1;
+                }
+                else if ( (true) ) {
+                    alt32=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return ;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 32, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else if ( (LA32_0==31||LA32_0==53) ) {
+                alt32=1;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 32, 0, input);
+
+                throw nvae;
+            }
+            switch (alt32) {
+                case 1 :
+                    // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+                    {
+                    // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+                    // InternalOXtype.g:2950:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); 
+                    }
+                    // InternalOXtype.g:2951:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+                    // InternalOXtype.g:2951:4: rule__XVariableDeclaration__Group_2_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XVariableDeclaration__Group_2_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2955:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) )
+                    {
+                    // InternalOXtype.g:2955:2: ( ( rule__XVariableDeclaration__NameAssignment_2_1 ) )
+                    // InternalOXtype.g:2956:3: ( rule__XVariableDeclaration__NameAssignment_2_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); 
+                    }
+                    // InternalOXtype.g:2957:3: ( rule__XVariableDeclaration__NameAssignment_2_1 )
+                    // InternalOXtype.g:2957:4: rule__XVariableDeclaration__NameAssignment_2_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XVariableDeclaration__NameAssignment_2_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Alternatives_2"
+
+
+    // $ANTLR start "rule__XFeatureCall__Alternatives_3_1"
+    // InternalOXtype.g:2965:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );
+    public final void rule__XFeatureCall__Alternatives_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2969:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) )
+            int alt33=2;
+            alt33 = dfa33.predict(input);
+            switch (alt33) {
+                case 1 :
+                    // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+                    {
+                    // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+                    // InternalOXtype.g:2971:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); 
+                    }
+                    // InternalOXtype.g:2972:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+                    // InternalOXtype.g:2972:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2976:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) )
+                    {
+                    // InternalOXtype.g:2976:2: ( ( rule__XFeatureCall__Group_3_1_1__0 ) )
+                    // InternalOXtype.g:2977:3: ( rule__XFeatureCall__Group_3_1_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); 
+                    }
+                    // InternalOXtype.g:2978:3: ( rule__XFeatureCall__Group_3_1_1__0 )
+                    // InternalOXtype.g:2978:4: rule__XFeatureCall__Group_3_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFeatureCall__Group_3_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Alternatives_3_1"
+
+
+    // $ANTLR start "rule__FeatureCallID__Alternatives"
+    // InternalOXtype.g:2986:1: rule__FeatureCallID__Alternatives : ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) );
+    public final void rule__FeatureCallID__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:2990:1: ( ( ruleValidID ) | ( 'extends' ) | ( 'static' ) | ( 'import' ) | ( 'extension' ) )
+            int alt34=5;
+            switch ( input.LA(1) ) {
+            case RULE_ID:
+                {
+                alt34=1;
+                }
+                break;
+            case 45:
+                {
+                alt34=2;
+                }
+                break;
+            case 46:
+                {
+                alt34=3;
+                }
+                break;
+            case 47:
+                {
+                alt34=4;
+                }
+                break;
+            case 48:
+                {
+                alt34=5;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 34, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt34) {
+                case 1 :
+                    // InternalOXtype.g:2991:2: ( ruleValidID )
+                    {
+                    // InternalOXtype.g:2991:2: ( ruleValidID )
+                    // InternalOXtype.g:2992:3: ruleValidID
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleValidID();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2997:2: ( 'extends' )
+                    {
+                    // InternalOXtype.g:2997:2: ( 'extends' )
+                    // InternalOXtype.g:2998:3: 'extends'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); 
+                    }
+                    match(input,45,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:3003:2: ( 'static' )
+                    {
+                    // InternalOXtype.g:3003:2: ( 'static' )
+                    // InternalOXtype.g:3004:3: 'static'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); 
+                    }
+                    match(input,46,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:3009:2: ( 'import' )
+                    {
+                    // InternalOXtype.g:3009:2: ( 'import' )
+                    // InternalOXtype.g:3010:3: 'import'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); 
+                    }
+                    match(input,47,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getFeatureCallIDAccess().getImportKeyword_3()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:3015:2: ( 'extension' )
+                    {
+                    // InternalOXtype.g:3015:2: ( 'extension' )
+                    // InternalOXtype.g:3016:3: 'extension'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); 
+                    }
+                    match(input,48,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FeatureCallID__Alternatives"
+
+
+    // $ANTLR start "rule__IdOrSuper__Alternatives"
+    // InternalOXtype.g:3025:1: rule__IdOrSuper__Alternatives : ( ( ruleFeatureCallID ) | ( 'super' ) );
+    public final void rule__IdOrSuper__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3029:1: ( ( ruleFeatureCallID ) | ( 'super' ) )
+            int alt35=2;
+            int LA35_0 = input.LA(1);
+
+            if ( (LA35_0==RULE_ID||(LA35_0>=45 && LA35_0<=48)) ) {
+                alt35=1;
+            }
+            else if ( (LA35_0==49) ) {
+                alt35=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 35, 0, input);
+
+                throw nvae;
+            }
+            switch (alt35) {
+                case 1 :
+                    // InternalOXtype.g:3030:2: ( ruleFeatureCallID )
+                    {
+                    // InternalOXtype.g:3030:2: ( ruleFeatureCallID )
+                    // InternalOXtype.g:3031:3: ruleFeatureCallID
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleFeatureCallID();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3036:2: ( 'super' )
+                    {
+                    // InternalOXtype.g:3036:2: ( 'super' )
+                    // InternalOXtype.g:3037:3: 'super'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); 
+                    }
+                    match(input,49,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getIdOrSuperAccess().getSuperKeyword_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__IdOrSuper__Alternatives"
+
+
+    // $ANTLR start "rule__XConstructorCall__Alternatives_4_1"
+    // InternalOXtype.g:3046:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );
+    public final void rule__XConstructorCall__Alternatives_4_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3050:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) )
+            int alt36=2;
+            alt36 = dfa36.predict(input);
+            switch (alt36) {
+                case 1 :
+                    // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+                    {
+                    // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+                    // InternalOXtype.g:3052:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); 
+                    }
+                    // InternalOXtype.g:3053:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+                    // InternalOXtype.g:3053:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XConstructorCall__ArgumentsAssignment_4_1_0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3057:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) )
+                    {
+                    // InternalOXtype.g:3057:2: ( ( rule__XConstructorCall__Group_4_1_1__0 ) )
+                    // InternalOXtype.g:3058:3: ( rule__XConstructorCall__Group_4_1_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); 
+                    }
+                    // InternalOXtype.g:3059:3: ( rule__XConstructorCall__Group_4_1_1__0 )
+                    // InternalOXtype.g:3059:4: rule__XConstructorCall__Group_4_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XConstructorCall__Group_4_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Alternatives_4_1"
+
+
+    // $ANTLR start "rule__XBooleanLiteral__Alternatives_1"
+    // InternalOXtype.g:3067:1: rule__XBooleanLiteral__Alternatives_1 : ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) );
+    public final void rule__XBooleanLiteral__Alternatives_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3071:1: ( ( 'false' ) | ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) ) )
+            int alt37=2;
+            int LA37_0 = input.LA(1);
+
+            if ( (LA37_0==50) ) {
+                alt37=1;
+            }
+            else if ( (LA37_0==88) ) {
+                alt37=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 37, 0, input);
+
+                throw nvae;
+            }
+            switch (alt37) {
+                case 1 :
+                    // InternalOXtype.g:3072:2: ( 'false' )
+                    {
+                    // InternalOXtype.g:3072:2: ( 'false' )
+                    // InternalOXtype.g:3073:3: 'false'
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); 
+                    }
+                    match(input,50,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3078:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) )
+                    {
+                    // InternalOXtype.g:3078:2: ( ( rule__XBooleanLiteral__IsTrueAssignment_1_1 ) )
+                    // InternalOXtype.g:3079:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); 
+                    }
+                    // InternalOXtype.g:3080:3: ( rule__XBooleanLiteral__IsTrueAssignment_1_1 )
+                    // InternalOXtype.g:3080:4: rule__XBooleanLiteral__IsTrueAssignment_1_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XBooleanLiteral__IsTrueAssignment_1_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXBooleanLiteralAccess().getIsTrueAssignment_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBooleanLiteral__Alternatives_1"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Alternatives_3"
+    // InternalOXtype.g:3088:1: rule__XTryCatchFinallyExpression__Alternatives_3 : ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) );
+    public final void rule__XTryCatchFinallyExpression__Alternatives_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3092:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) ) | ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) ) )
+            int alt38=2;
+            int LA38_0 = input.LA(1);
+
+            if ( (LA38_0==80) ) {
+                alt38=1;
+            }
+            else if ( (LA38_0==78) ) {
+                alt38=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 38, 0, input);
+
+                throw nvae;
+            }
+            switch (alt38) {
+                case 1 :
+                    // InternalOXtype.g:3093:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) )
+                    {
+                    // InternalOXtype.g:3093:2: ( ( rule__XTryCatchFinallyExpression__Group_3_0__0 ) )
+                    // InternalOXtype.g:3094:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); 
+                    }
+                    // InternalOXtype.g:3095:3: ( rule__XTryCatchFinallyExpression__Group_3_0__0 )
+                    // InternalOXtype.g:3095:4: rule__XTryCatchFinallyExpression__Group_3_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XTryCatchFinallyExpression__Group_3_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3099:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) )
+                    {
+                    // InternalOXtype.g:3099:2: ( ( rule__XTryCatchFinallyExpression__Group_3_1__0 ) )
+                    // InternalOXtype.g:3100:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); 
+                    }
+                    // InternalOXtype.g:3101:3: ( rule__XTryCatchFinallyExpression__Group_3_1__0 )
+                    // InternalOXtype.g:3101:4: rule__XTryCatchFinallyExpression__Group_3_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XTryCatchFinallyExpression__Group_3_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Alternatives_3"
+
+
+    // $ANTLR start "rule__Number__Alternatives"
+    // InternalOXtype.g:3109:1: rule__Number__Alternatives : ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) );
+    public final void rule__Number__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3113:1: ( ( RULE_HEX ) | ( ( rule__Number__Group_1__0 ) ) )
+            int alt39=2;
+            int LA39_0 = input.LA(1);
+
+            if ( (LA39_0==RULE_HEX) ) {
+                alt39=1;
+            }
+            else if ( ((LA39_0>=RULE_INT && LA39_0<=RULE_DECIMAL)) ) {
+                alt39=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 39, 0, input);
+
+                throw nvae;
+            }
+            switch (alt39) {
+                case 1 :
+                    // InternalOXtype.g:3114:2: ( RULE_HEX )
+                    {
+                    // InternalOXtype.g:3114:2: ( RULE_HEX )
+                    // InternalOXtype.g:3115:3: RULE_HEX
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); 
+                    }
+                    match(input,RULE_HEX,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3120:2: ( ( rule__Number__Group_1__0 ) )
+                    {
+                    // InternalOXtype.g:3120:2: ( ( rule__Number__Group_1__0 ) )
+                    // InternalOXtype.g:3121:3: ( rule__Number__Group_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getNumberAccess().getGroup_1()); 
+                    }
+                    // InternalOXtype.g:3122:3: ( rule__Number__Group_1__0 )
+                    // InternalOXtype.g:3122:4: rule__Number__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__Number__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getNumberAccess().getGroup_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Alternatives"
+
+
+    // $ANTLR start "rule__Number__Alternatives_1_0"
+    // InternalOXtype.g:3130:1: rule__Number__Alternatives_1_0 : ( ( RULE_INT ) | ( RULE_DECIMAL ) );
+    public final void rule__Number__Alternatives_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3134:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) )
+            int alt40=2;
+            int LA40_0 = input.LA(1);
+
+            if ( (LA40_0==RULE_INT) ) {
+                alt40=1;
+            }
+            else if ( (LA40_0==RULE_DECIMAL) ) {
+                alt40=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 40, 0, input);
+
+                throw nvae;
+            }
+            switch (alt40) {
+                case 1 :
+                    // InternalOXtype.g:3135:2: ( RULE_INT )
+                    {
+                    // InternalOXtype.g:3135:2: ( RULE_INT )
+                    // InternalOXtype.g:3136:3: RULE_INT
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); 
+                    }
+                    match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3141:2: ( RULE_DECIMAL )
+                    {
+                    // InternalOXtype.g:3141:2: ( RULE_DECIMAL )
+                    // InternalOXtype.g:3142:3: RULE_DECIMAL
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); 
+                    }
+                    match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Alternatives_1_0"
+
+
+    // $ANTLR start "rule__Number__Alternatives_1_1_1"
+    // InternalOXtype.g:3151:1: rule__Number__Alternatives_1_1_1 : ( ( RULE_INT ) | ( RULE_DECIMAL ) );
+    public final void rule__Number__Alternatives_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3155:1: ( ( RULE_INT ) | ( RULE_DECIMAL ) )
+            int alt41=2;
+            int LA41_0 = input.LA(1);
+
+            if ( (LA41_0==RULE_INT) ) {
+                alt41=1;
+            }
+            else if ( (LA41_0==RULE_DECIMAL) ) {
+                alt41=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 41, 0, input);
+
+                throw nvae;
+            }
+            switch (alt41) {
+                case 1 :
+                    // InternalOXtype.g:3156:2: ( RULE_INT )
+                    {
+                    // InternalOXtype.g:3156:2: ( RULE_INT )
+                    // InternalOXtype.g:3157:3: RULE_INT
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); 
+                    }
+                    match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3162:2: ( RULE_DECIMAL )
+                    {
+                    // InternalOXtype.g:3162:2: ( RULE_DECIMAL )
+                    // InternalOXtype.g:3163:3: RULE_DECIMAL
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); 
+                    }
+                    match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Alternatives_1_1_1"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Alternatives"
+    // InternalOXtype.g:3172:1: rule__JvmTypeReference__Alternatives : ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) );
+    public final void rule__JvmTypeReference__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3176:1: ( ( ( rule__JvmTypeReference__Group_0__0 ) ) | ( ruleXFunctionTypeRef ) )
+            int alt42=2;
+            int LA42_0 = input.LA(1);
+
+            if ( (LA42_0==RULE_ID) ) {
+                alt42=1;
+            }
+            else if ( (LA42_0==31||LA42_0==53) ) {
+                alt42=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 42, 0, input);
+
+                throw nvae;
+            }
+            switch (alt42) {
+                case 1 :
+                    // InternalOXtype.g:3177:2: ( ( rule__JvmTypeReference__Group_0__0 ) )
+                    {
+                    // InternalOXtype.g:3177:2: ( ( rule__JvmTypeReference__Group_0__0 ) )
+                    // InternalOXtype.g:3178:3: ( rule__JvmTypeReference__Group_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); 
+                    }
+                    // InternalOXtype.g:3179:3: ( rule__JvmTypeReference__Group_0__0 )
+                    // InternalOXtype.g:3179:4: rule__JvmTypeReference__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmTypeReference__Group_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3183:2: ( ruleXFunctionTypeRef )
+                    {
+                    // InternalOXtype.g:3183:2: ( ruleXFunctionTypeRef )
+                    // InternalOXtype.g:3184:3: ruleXFunctionTypeRef
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleXFunctionTypeRef();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Alternatives"
+
+
+    // $ANTLR start "rule__JvmArgumentTypeReference__Alternatives"
+    // InternalOXtype.g:3193:1: rule__JvmArgumentTypeReference__Alternatives : ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) );
+    public final void rule__JvmArgumentTypeReference__Alternatives() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3197:1: ( ( ruleJvmTypeReference ) | ( ruleJvmWildcardTypeReference ) )
+            int alt43=2;
+            int LA43_0 = input.LA(1);
+
+            if ( (LA43_0==RULE_ID||LA43_0==31||LA43_0==53) ) {
+                alt43=1;
+            }
+            else if ( (LA43_0==81) ) {
+                alt43=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 43, 0, input);
+
+                throw nvae;
+            }
+            switch (alt43) {
+                case 1 :
+                    // InternalOXtype.g:3198:2: ( ruleJvmTypeReference )
+                    {
+                    // InternalOXtype.g:3198:2: ( ruleJvmTypeReference )
+                    // InternalOXtype.g:3199:3: ruleJvmTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleJvmTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3204:2: ( ruleJvmWildcardTypeReference )
+                    {
+                    // InternalOXtype.g:3204:2: ( ruleJvmWildcardTypeReference )
+                    // InternalOXtype.g:3205:3: ruleJvmWildcardTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); 
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleJvmWildcardTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmArgumentTypeReference__Alternatives"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Alternatives_2"
+    // InternalOXtype.g:3214:1: rule__JvmWildcardTypeReference__Alternatives_2 : ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) );
+    public final void rule__JvmWildcardTypeReference__Alternatives_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3218:1: ( ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) ) | ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) ) )
+            int alt44=2;
+            int LA44_0 = input.LA(1);
+
+            if ( (LA44_0==45) ) {
+                alt44=1;
+            }
+            else if ( (LA44_0==49) ) {
+                alt44=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return ;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 44, 0, input);
+
+                throw nvae;
+            }
+            switch (alt44) {
+                case 1 :
+                    // InternalOXtype.g:3219:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) )
+                    {
+                    // InternalOXtype.g:3219:2: ( ( rule__JvmWildcardTypeReference__Group_2_0__0 ) )
+                    // InternalOXtype.g:3220:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); 
+                    }
+                    // InternalOXtype.g:3221:3: ( rule__JvmWildcardTypeReference__Group_2_0__0 )
+                    // InternalOXtype.g:3221:4: rule__JvmWildcardTypeReference__Group_2_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmWildcardTypeReference__Group_2_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_0()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3225:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) )
+                    {
+                    // InternalOXtype.g:3225:2: ( ( rule__JvmWildcardTypeReference__Group_2_1__0 ) )
+                    // InternalOXtype.g:3226:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 )
+                    {
+                    if ( state.backtracking==0 ) {
+                       before(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); 
+                    }
+                    // InternalOXtype.g:3227:3: ( rule__JvmWildcardTypeReference__Group_2_1__0 )
+                    // InternalOXtype.g:3227:4: rule__JvmWildcardTypeReference__Group_2_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmWildcardTypeReference__Group_2_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+                       after(grammarAccess.getJvmWildcardTypeReferenceAccess().getGroup_2_1()); 
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Alternatives_2"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__0"
+    // InternalOXtype.g:3235:1: rule__XImportDeclaration__Group__0 : rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 ;
+    public final void rule__XImportDeclaration__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3239:1: ( rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1 )
+            // InternalOXtype.g:3240:2: rule__XImportDeclaration__Group__0__Impl rule__XImportDeclaration__Group__1
+            {
+            pushFollow(FOLLOW_4);
+            rule__XImportDeclaration__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__0"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__0__Impl"
+    // InternalOXtype.g:3247:1: rule__XImportDeclaration__Group__0__Impl : ( () ) ;
+    public final void rule__XImportDeclaration__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3251:1: ( ( () ) )
+            // InternalOXtype.g:3252:1: ( () )
+            {
+            // InternalOXtype.g:3252:1: ( () )
+            // InternalOXtype.g:3253:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0()); 
+            }
+            // InternalOXtype.g:3254:2: ()
+            // InternalOXtype.g:3254:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__1"
+    // InternalOXtype.g:3262:1: rule__XImportDeclaration__Group__1 : rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 ;
+    public final void rule__XImportDeclaration__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3266:1: ( rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2 )
+            // InternalOXtype.g:3267:2: rule__XImportDeclaration__Group__1__Impl rule__XImportDeclaration__Group__2
+            {
+            pushFollow(FOLLOW_5);
+            rule__XImportDeclaration__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__1"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__1__Impl"
+    // InternalOXtype.g:3274:1: rule__XImportDeclaration__Group__1__Impl : ( 'import' ) ;
+    public final void rule__XImportDeclaration__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3278:1: ( ( 'import' ) )
+            // InternalOXtype.g:3279:1: ( 'import' )
+            {
+            // InternalOXtype.g:3279:1: ( 'import' )
+            // InternalOXtype.g:3280:2: 'import'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1()); 
+            }
+            match(input,47,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__2"
+    // InternalOXtype.g:3289:1: rule__XImportDeclaration__Group__2 : rule__XImportDeclaration__Group__2__Impl rule__XImportDeclaration__Group__3 ;
+    public final void rule__XImportDeclaration__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3293:1: ( rule__XImportDeclaration__Group__2__Impl rule__XImportDeclaration__Group__3 )
+            // InternalOXtype.g:3294:2: rule__XImportDeclaration__Group__2__Impl rule__XImportDeclaration__Group__3
+            {
+            pushFollow(FOLLOW_6);
+            rule__XImportDeclaration__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__2"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__2__Impl"
+    // InternalOXtype.g:3301:1: rule__XImportDeclaration__Group__2__Impl : ( ( rule__XImportDeclaration__Alternatives_2 ) ) ;
+    public final void rule__XImportDeclaration__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3305:1: ( ( ( rule__XImportDeclaration__Alternatives_2 ) ) )
+            // InternalOXtype.g:3306:1: ( ( rule__XImportDeclaration__Alternatives_2 ) )
+            {
+            // InternalOXtype.g:3306:1: ( ( rule__XImportDeclaration__Alternatives_2 ) )
+            // InternalOXtype.g:3307:2: ( rule__XImportDeclaration__Alternatives_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2()); 
+            }
+            // InternalOXtype.g:3308:2: ( rule__XImportDeclaration__Alternatives_2 )
+            // InternalOXtype.g:3308:3: rule__XImportDeclaration__Alternatives_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Alternatives_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__3"
+    // InternalOXtype.g:3316:1: rule__XImportDeclaration__Group__3 : rule__XImportDeclaration__Group__3__Impl ;
+    public final void rule__XImportDeclaration__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3320:1: ( rule__XImportDeclaration__Group__3__Impl )
+            // InternalOXtype.g:3321:2: rule__XImportDeclaration__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__3"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group__3__Impl"
+    // InternalOXtype.g:3327:1: rule__XImportDeclaration__Group__3__Impl : ( ( ';' )? ) ;
+    public final void rule__XImportDeclaration__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3331:1: ( ( ( ';' )? ) )
+            // InternalOXtype.g:3332:1: ( ( ';' )? )
+            {
+            // InternalOXtype.g:3332:1: ( ( ';' )? )
+            // InternalOXtype.g:3333:2: ( ';' )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3()); 
+            }
+            // InternalOXtype.g:3334:2: ( ';' )?
+            int alt45=2;
+            int LA45_0 = input.LA(1);
+
+            if ( (LA45_0==51) ) {
+                alt45=1;
+            }
+            switch (alt45) {
+                case 1 :
+                    // InternalOXtype.g:3334:3: ';'
+                    {
+                    match(input,51,FOLLOW_2); if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__0"
+    // InternalOXtype.g:3343:1: rule__XImportDeclaration__Group_2_0__0 : rule__XImportDeclaration__Group_2_0__0__Impl rule__XImportDeclaration__Group_2_0__1 ;
+    public final void rule__XImportDeclaration__Group_2_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3347:1: ( rule__XImportDeclaration__Group_2_0__0__Impl rule__XImportDeclaration__Group_2_0__1 )
+            // InternalOXtype.g:3348:2: rule__XImportDeclaration__Group_2_0__0__Impl rule__XImportDeclaration__Group_2_0__1
+            {
+            pushFollow(FOLLOW_7);
+            rule__XImportDeclaration__Group_2_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group_2_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__0"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__0__Impl"
+    // InternalOXtype.g:3355:1: rule__XImportDeclaration__Group_2_0__0__Impl : ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) ) ;
+    public final void rule__XImportDeclaration__Group_2_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3359:1: ( ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) ) )
+            // InternalOXtype.g:3360:1: ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) )
+            {
+            // InternalOXtype.g:3360:1: ( ( rule__XImportDeclaration__StaticAssignment_2_0_0 ) )
+            // InternalOXtype.g:3361:2: ( rule__XImportDeclaration__StaticAssignment_2_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0()); 
+            }
+            // InternalOXtype.g:3362:2: ( rule__XImportDeclaration__StaticAssignment_2_0_0 )
+            // InternalOXtype.g:3362:3: rule__XImportDeclaration__StaticAssignment_2_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__StaticAssignment_2_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getStaticAssignment_2_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__0__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__1"
+    // InternalOXtype.g:3370:1: rule__XImportDeclaration__Group_2_0__1 : rule__XImportDeclaration__Group_2_0__1__Impl rule__XImportDeclaration__Group_2_0__2 ;
+    public final void rule__XImportDeclaration__Group_2_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3374:1: ( rule__XImportDeclaration__Group_2_0__1__Impl rule__XImportDeclaration__Group_2_0__2 )
+            // InternalOXtype.g:3375:2: rule__XImportDeclaration__Group_2_0__1__Impl rule__XImportDeclaration__Group_2_0__2
+            {
+            pushFollow(FOLLOW_7);
+            rule__XImportDeclaration__Group_2_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group_2_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__1"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__1__Impl"
+    // InternalOXtype.g:3382:1: rule__XImportDeclaration__Group_2_0__1__Impl : ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? ) ;
+    public final void rule__XImportDeclaration__Group_2_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3386:1: ( ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? ) )
+            // InternalOXtype.g:3387:1: ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? )
+            {
+            // InternalOXtype.g:3387:1: ( ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )? )
+            // InternalOXtype.g:3388:2: ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1()); 
+            }
+            // InternalOXtype.g:3389:2: ( rule__XImportDeclaration__ExtensionAssignment_2_0_1 )?
+            int alt46=2;
+            int LA46_0 = input.LA(1);
+
+            if ( (LA46_0==48) ) {
+                alt46=1;
+            }
+            switch (alt46) {
+                case 1 :
+                    // InternalOXtype.g:3389:3: rule__XImportDeclaration__ExtensionAssignment_2_0_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XImportDeclaration__ExtensionAssignment_2_0_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getExtensionAssignment_2_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__1__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__2"
+    // InternalOXtype.g:3397:1: rule__XImportDeclaration__Group_2_0__2 : rule__XImportDeclaration__Group_2_0__2__Impl rule__XImportDeclaration__Group_2_0__3 ;
+    public final void rule__XImportDeclaration__Group_2_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3401:1: ( rule__XImportDeclaration__Group_2_0__2__Impl rule__XImportDeclaration__Group_2_0__3 )
+            // InternalOXtype.g:3402:2: rule__XImportDeclaration__Group_2_0__2__Impl rule__XImportDeclaration__Group_2_0__3
+            {
+            pushFollow(FOLLOW_8);
+            rule__XImportDeclaration__Group_2_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group_2_0__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__2"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__2__Impl"
+    // InternalOXtype.g:3409:1: rule__XImportDeclaration__Group_2_0__2__Impl : ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) ) ;
+    public final void rule__XImportDeclaration__Group_2_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3413:1: ( ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) ) )
+            // InternalOXtype.g:3414:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) )
+            {
+            // InternalOXtype.g:3414:1: ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 ) )
+            // InternalOXtype.g:3415:2: ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2()); 
+            }
+            // InternalOXtype.g:3416:2: ( rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 )
+            // InternalOXtype.g:3416:3: rule__XImportDeclaration__ImportedTypeAssignment_2_0_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__ImportedTypeAssignment_2_0_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_2_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__2__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__3"
+    // InternalOXtype.g:3424:1: rule__XImportDeclaration__Group_2_0__3 : rule__XImportDeclaration__Group_2_0__3__Impl ;
+    public final void rule__XImportDeclaration__Group_2_0__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3428:1: ( rule__XImportDeclaration__Group_2_0__3__Impl )
+            // InternalOXtype.g:3429:2: rule__XImportDeclaration__Group_2_0__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group_2_0__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__3"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_0__3__Impl"
+    // InternalOXtype.g:3435:1: rule__XImportDeclaration__Group_2_0__3__Impl : ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) ) ;
+    public final void rule__XImportDeclaration__Group_2_0__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3439:1: ( ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) ) )
+            // InternalOXtype.g:3440:1: ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) )
+            {
+            // InternalOXtype.g:3440:1: ( ( rule__XImportDeclaration__Alternatives_2_0_3 ) )
+            // InternalOXtype.g:3441:2: ( rule__XImportDeclaration__Alternatives_2_0_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3()); 
+            }
+            // InternalOXtype.g:3442:2: ( rule__XImportDeclaration__Alternatives_2_0_3 )
+            // InternalOXtype.g:3442:3: rule__XImportDeclaration__Alternatives_2_0_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Alternatives_2_0_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getAlternatives_2_0_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_0__3__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_3__0"
+    // InternalOXtype.g:3451:1: rule__XImportDeclaration__Group_2_3__0 : rule__XImportDeclaration__Group_2_3__0__Impl rule__XImportDeclaration__Group_2_3__1 ;
+    public final void rule__XImportDeclaration__Group_2_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3455:1: ( rule__XImportDeclaration__Group_2_3__0__Impl rule__XImportDeclaration__Group_2_3__1 )
+            // InternalOXtype.g:3456:2: rule__XImportDeclaration__Group_2_3__0__Impl rule__XImportDeclaration__Group_2_3__1
+            {
+            pushFollow(FOLLOW_9);
+            rule__XImportDeclaration__Group_2_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group_2_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_3__0"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_3__0__Impl"
+    // InternalOXtype.g:3463:1: rule__XImportDeclaration__Group_2_3__0__Impl : ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) ) ;
+    public final void rule__XImportDeclaration__Group_2_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3467:1: ( ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) ) )
+            // InternalOXtype.g:3468:1: ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) )
+            {
+            // InternalOXtype.g:3468:1: ( ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 ) )
+            // InternalOXtype.g:3469:2: ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0()); 
+            }
+            // InternalOXtype.g:3470:2: ( rule__XImportDeclaration__FqnImportAssignment_2_3_0 )
+            // InternalOXtype.g:3470:3: rule__XImportDeclaration__FqnImportAssignment_2_3_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__FqnImportAssignment_2_3_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getFqnImportAssignment_2_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_3__0__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_3__1"
+    // InternalOXtype.g:3478:1: rule__XImportDeclaration__Group_2_3__1 : rule__XImportDeclaration__Group_2_3__1__Impl ;
+    public final void rule__XImportDeclaration__Group_2_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3482:1: ( rule__XImportDeclaration__Group_2_3__1__Impl )
+            // InternalOXtype.g:3483:2: rule__XImportDeclaration__Group_2_3__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__Group_2_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_3__1"
+
+
+    // $ANTLR start "rule__XImportDeclaration__Group_2_3__1__Impl"
+    // InternalOXtype.g:3489:1: rule__XImportDeclaration__Group_2_3__1__Impl : ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) ) ;
+    public final void rule__XImportDeclaration__Group_2_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3493:1: ( ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) ) )
+            // InternalOXtype.g:3494:1: ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) )
+            {
+            // InternalOXtype.g:3494:1: ( ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 ) )
+            // InternalOXtype.g:3495:2: ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1()); 
+            }
+            // InternalOXtype.g:3496:2: ( rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 )
+            // InternalOXtype.g:3496:3: rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameAssignment_2_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__Group_2_3__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__0"
+    // InternalOXtype.g:3505:1: rule__XAnnotation__Group__0 : rule__XAnnotation__Group__0__Impl rule__XAnnotation__Group__1 ;
+    public final void rule__XAnnotation__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3509:1: ( rule__XAnnotation__Group__0__Impl rule__XAnnotation__Group__1 )
+            // InternalOXtype.g:3510:2: rule__XAnnotation__Group__0__Impl rule__XAnnotation__Group__1
+            {
+            pushFollow(FOLLOW_10);
+            rule__XAnnotation__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__0"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__0__Impl"
+    // InternalOXtype.g:3517:1: rule__XAnnotation__Group__0__Impl : ( () ) ;
+    public final void rule__XAnnotation__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3521:1: ( ( () ) )
+            // InternalOXtype.g:3522:1: ( () )
+            {
+            // InternalOXtype.g:3522:1: ( () )
+            // InternalOXtype.g:3523:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0()); 
+            }
+            // InternalOXtype.g:3524:2: ()
+            // InternalOXtype.g:3524:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getXAnnotationAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__1"
+    // InternalOXtype.g:3532:1: rule__XAnnotation__Group__1 : rule__XAnnotation__Group__1__Impl rule__XAnnotation__Group__2 ;
+    public final void rule__XAnnotation__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3536:1: ( rule__XAnnotation__Group__1__Impl rule__XAnnotation__Group__2 )
+            // InternalOXtype.g:3537:2: rule__XAnnotation__Group__1__Impl rule__XAnnotation__Group__2
+            {
+            pushFollow(FOLLOW_9);
+            rule__XAnnotation__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__1"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__1__Impl"
+    // InternalOXtype.g:3544:1: rule__XAnnotation__Group__1__Impl : ( '@' ) ;
+    public final void rule__XAnnotation__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3548:1: ( ( '@' ) )
+            // InternalOXtype.g:3549:1: ( '@' )
+            {
+            // InternalOXtype.g:3549:1: ( '@' )
+            // InternalOXtype.g:3550:2: '@'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1()); 
+            }
+            match(input,52,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__2"
+    // InternalOXtype.g:3559:1: rule__XAnnotation__Group__2 : rule__XAnnotation__Group__2__Impl rule__XAnnotation__Group__3 ;
+    public final void rule__XAnnotation__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3563:1: ( rule__XAnnotation__Group__2__Impl rule__XAnnotation__Group__3 )
+            // InternalOXtype.g:3564:2: rule__XAnnotation__Group__2__Impl rule__XAnnotation__Group__3
+            {
+            pushFollow(FOLLOW_11);
+            rule__XAnnotation__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__2"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__2__Impl"
+    // InternalOXtype.g:3571:1: rule__XAnnotation__Group__2__Impl : ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) ) ;
+    public final void rule__XAnnotation__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3575:1: ( ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) ) )
+            // InternalOXtype.g:3576:1: ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) )
+            {
+            // InternalOXtype.g:3576:1: ( ( rule__XAnnotation__AnnotationTypeAssignment_2 ) )
+            // InternalOXtype.g:3577:2: ( rule__XAnnotation__AnnotationTypeAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2()); 
+            }
+            // InternalOXtype.g:3578:2: ( rule__XAnnotation__AnnotationTypeAssignment_2 )
+            // InternalOXtype.g:3578:3: rule__XAnnotation__AnnotationTypeAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__AnnotationTypeAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getAnnotationTypeAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__3"
+    // InternalOXtype.g:3586:1: rule__XAnnotation__Group__3 : rule__XAnnotation__Group__3__Impl ;
+    public final void rule__XAnnotation__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3590:1: ( rule__XAnnotation__Group__3__Impl )
+            // InternalOXtype.g:3591:2: rule__XAnnotation__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__3"
+
+
+    // $ANTLR start "rule__XAnnotation__Group__3__Impl"
+    // InternalOXtype.g:3597:1: rule__XAnnotation__Group__3__Impl : ( ( rule__XAnnotation__Group_3__0 )? ) ;
+    public final void rule__XAnnotation__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3601:1: ( ( ( rule__XAnnotation__Group_3__0 )? ) )
+            // InternalOXtype.g:3602:1: ( ( rule__XAnnotation__Group_3__0 )? )
+            {
+            // InternalOXtype.g:3602:1: ( ( rule__XAnnotation__Group_3__0 )? )
+            // InternalOXtype.g:3603:2: ( rule__XAnnotation__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:3604:2: ( rule__XAnnotation__Group_3__0 )?
+            int alt47=2;
+            int LA47_0 = input.LA(1);
+
+            if ( (LA47_0==53) ) {
+                alt47=1;
+            }
+            switch (alt47) {
+                case 1 :
+                    // InternalOXtype.g:3604:3: rule__XAnnotation__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotation__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3__0"
+    // InternalOXtype.g:3613:1: rule__XAnnotation__Group_3__0 : rule__XAnnotation__Group_3__0__Impl rule__XAnnotation__Group_3__1 ;
+    public final void rule__XAnnotation__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3617:1: ( rule__XAnnotation__Group_3__0__Impl rule__XAnnotation__Group_3__1 )
+            // InternalOXtype.g:3618:2: rule__XAnnotation__Group_3__0__Impl rule__XAnnotation__Group_3__1
+            {
+            pushFollow(FOLLOW_12);
+            rule__XAnnotation__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3__0"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3__0__Impl"
+    // InternalOXtype.g:3625:1: rule__XAnnotation__Group_3__0__Impl : ( ( '(' ) ) ;
+    public final void rule__XAnnotation__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3629:1: ( ( ( '(' ) ) )
+            // InternalOXtype.g:3630:1: ( ( '(' ) )
+            {
+            // InternalOXtype.g:3630:1: ( ( '(' ) )
+            // InternalOXtype.g:3631:2: ( '(' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()); 
+            }
+            // InternalOXtype.g:3632:2: ( '(' )
+            // InternalOXtype.g:3632:3: '('
+            {
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3__1"
+    // InternalOXtype.g:3640:1: rule__XAnnotation__Group_3__1 : rule__XAnnotation__Group_3__1__Impl rule__XAnnotation__Group_3__2 ;
+    public final void rule__XAnnotation__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3644:1: ( rule__XAnnotation__Group_3__1__Impl rule__XAnnotation__Group_3__2 )
+            // InternalOXtype.g:3645:2: rule__XAnnotation__Group_3__1__Impl rule__XAnnotation__Group_3__2
+            {
+            pushFollow(FOLLOW_12);
+            rule__XAnnotation__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3__1"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3__1__Impl"
+    // InternalOXtype.g:3652:1: rule__XAnnotation__Group_3__1__Impl : ( ( rule__XAnnotation__Alternatives_3_1 )? ) ;
+    public final void rule__XAnnotation__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3656:1: ( ( ( rule__XAnnotation__Alternatives_3_1 )? ) )
+            // InternalOXtype.g:3657:1: ( ( rule__XAnnotation__Alternatives_3_1 )? )
+            {
+            // InternalOXtype.g:3657:1: ( ( rule__XAnnotation__Alternatives_3_1 )? )
+            // InternalOXtype.g:3658:2: ( rule__XAnnotation__Alternatives_3_1 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getAlternatives_3_1()); 
+            }
+            // InternalOXtype.g:3659:2: ( rule__XAnnotation__Alternatives_3_1 )?
+            int alt48=2;
+            int LA48_0 = input.LA(1);
+
+            if ( ((LA48_0>=RULE_ID && LA48_0<=RULE_STRING)||LA48_0==27||(LA48_0>=34 && LA48_0<=35)||LA48_0==40||(LA48_0>=45 && LA48_0<=50)||(LA48_0>=52 && LA48_0<=53)||(LA48_0>=57 && LA48_0<=58)||LA48_0==61||LA48_0==63||LA48_0==65||(LA48_0>=69 && LA48_0<=77)||LA48_0==79||LA48_0==88) ) {
+                alt48=1;
+            }
+            switch (alt48) {
+                case 1 :
+                    // InternalOXtype.g:3659:3: rule__XAnnotation__Alternatives_3_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotation__Alternatives_3_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getAlternatives_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3__2"
+    // InternalOXtype.g:3667:1: rule__XAnnotation__Group_3__2 : rule__XAnnotation__Group_3__2__Impl ;
+    public final void rule__XAnnotation__Group_3__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3671:1: ( rule__XAnnotation__Group_3__2__Impl )
+            // InternalOXtype.g:3672:2: rule__XAnnotation__Group_3__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3__2"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3__2__Impl"
+    // InternalOXtype.g:3678:1: rule__XAnnotation__Group_3__2__Impl : ( ')' ) ;
+    public final void rule__XAnnotation__Group_3__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3682:1: ( ( ')' ) )
+            // InternalOXtype.g:3683:1: ( ')' )
+            {
+            // InternalOXtype.g:3683:1: ( ')' )
+            // InternalOXtype.g:3684:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3__2__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0__0"
+    // InternalOXtype.g:3694:1: rule__XAnnotation__Group_3_1_0__0 : rule__XAnnotation__Group_3_1_0__0__Impl rule__XAnnotation__Group_3_1_0__1 ;
+    public final void rule__XAnnotation__Group_3_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3698:1: ( rule__XAnnotation__Group_3_1_0__0__Impl rule__XAnnotation__Group_3_1_0__1 )
+            // InternalOXtype.g:3699:2: rule__XAnnotation__Group_3_1_0__0__Impl rule__XAnnotation__Group_3_1_0__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XAnnotation__Group_3_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3_1_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0__0"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0__0__Impl"
+    // InternalOXtype.g:3706:1: rule__XAnnotation__Group_3_1_0__0__Impl : ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) ) ;
+    public final void rule__XAnnotation__Group_3_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3710:1: ( ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) ) )
+            // InternalOXtype.g:3711:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) )
+            {
+            // InternalOXtype.g:3711:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 ) )
+            // InternalOXtype.g:3712:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0()); 
+            }
+            // InternalOXtype.g:3713:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 )
+            // InternalOXtype.g:3713:3: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0__1"
+    // InternalOXtype.g:3721:1: rule__XAnnotation__Group_3_1_0__1 : rule__XAnnotation__Group_3_1_0__1__Impl ;
+    public final void rule__XAnnotation__Group_3_1_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3725:1: ( rule__XAnnotation__Group_3_1_0__1__Impl )
+            // InternalOXtype.g:3726:2: rule__XAnnotation__Group_3_1_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3_1_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0__1"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0__1__Impl"
+    // InternalOXtype.g:3732:1: rule__XAnnotation__Group_3_1_0__1__Impl : ( ( rule__XAnnotation__Group_3_1_0_1__0 )* ) ;
+    public final void rule__XAnnotation__Group_3_1_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3736:1: ( ( ( rule__XAnnotation__Group_3_1_0_1__0 )* ) )
+            // InternalOXtype.g:3737:1: ( ( rule__XAnnotation__Group_3_1_0_1__0 )* )
+            {
+            // InternalOXtype.g:3737:1: ( ( rule__XAnnotation__Group_3_1_0_1__0 )* )
+            // InternalOXtype.g:3738:2: ( rule__XAnnotation__Group_3_1_0_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1()); 
+            }
+            // InternalOXtype.g:3739:2: ( rule__XAnnotation__Group_3_1_0_1__0 )*
+            loop49:
+            do {
+                int alt49=2;
+                int LA49_0 = input.LA(1);
+
+                if ( (LA49_0==55) ) {
+                    alt49=1;
+                }
+
+
+                switch (alt49) {
+            	case 1 :
+            	    // InternalOXtype.g:3739:3: rule__XAnnotation__Group_3_1_0_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XAnnotation__Group_3_1_0_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop49;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getGroup_3_1_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__0"
+    // InternalOXtype.g:3748:1: rule__XAnnotation__Group_3_1_0_1__0 : rule__XAnnotation__Group_3_1_0_1__0__Impl rule__XAnnotation__Group_3_1_0_1__1 ;
+    public final void rule__XAnnotation__Group_3_1_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3752:1: ( rule__XAnnotation__Group_3_1_0_1__0__Impl rule__XAnnotation__Group_3_1_0_1__1 )
+            // InternalOXtype.g:3753:2: rule__XAnnotation__Group_3_1_0_1__0__Impl rule__XAnnotation__Group_3_1_0_1__1
+            {
+            pushFollow(FOLLOW_9);
+            rule__XAnnotation__Group_3_1_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3_1_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__0"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__0__Impl"
+    // InternalOXtype.g:3760:1: rule__XAnnotation__Group_3_1_0_1__0__Impl : ( ',' ) ;
+    public final void rule__XAnnotation__Group_3_1_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3764:1: ( ( ',' ) )
+            // InternalOXtype.g:3765:1: ( ',' )
+            {
+            // InternalOXtype.g:3765:1: ( ',' )
+            // InternalOXtype.g:3766:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__1"
+    // InternalOXtype.g:3775:1: rule__XAnnotation__Group_3_1_0_1__1 : rule__XAnnotation__Group_3_1_0_1__1__Impl ;
+    public final void rule__XAnnotation__Group_3_1_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3779:1: ( rule__XAnnotation__Group_3_1_0_1__1__Impl )
+            // InternalOXtype.g:3780:2: rule__XAnnotation__Group_3_1_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__Group_3_1_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__1"
+
+
+    // $ANTLR start "rule__XAnnotation__Group_3_1_0_1__1__Impl"
+    // InternalOXtype.g:3786:1: rule__XAnnotation__Group_3_1_0_1__1__Impl : ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) ) ;
+    public final void rule__XAnnotation__Group_3_1_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3790:1: ( ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) ) )
+            // InternalOXtype.g:3791:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) )
+            {
+            // InternalOXtype.g:3791:1: ( ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 ) )
+            // InternalOXtype.g:3792:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1()); 
+            }
+            // InternalOXtype.g:3793:2: ( rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 )
+            // InternalOXtype.g:3793:3: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getElementValuePairsAssignment_3_1_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__Group_3_1_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group__0"
+    // InternalOXtype.g:3802:1: rule__XAnnotationElementValuePair__Group__0 : rule__XAnnotationElementValuePair__Group__0__Impl rule__XAnnotationElementValuePair__Group__1 ;
+    public final void rule__XAnnotationElementValuePair__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3806:1: ( rule__XAnnotationElementValuePair__Group__0__Impl rule__XAnnotationElementValuePair__Group__1 )
+            // InternalOXtype.g:3807:2: rule__XAnnotationElementValuePair__Group__0__Impl rule__XAnnotationElementValuePair__Group__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAnnotationElementValuePair__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group__0__Impl"
+    // InternalOXtype.g:3814:1: rule__XAnnotationElementValuePair__Group__0__Impl : ( ( rule__XAnnotationElementValuePair__Group_0__0 ) ) ;
+    public final void rule__XAnnotationElementValuePair__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3818:1: ( ( ( rule__XAnnotationElementValuePair__Group_0__0 ) ) )
+            // InternalOXtype.g:3819:1: ( ( rule__XAnnotationElementValuePair__Group_0__0 ) )
+            {
+            // InternalOXtype.g:3819:1: ( ( rule__XAnnotationElementValuePair__Group_0__0 ) )
+            // InternalOXtype.g:3820:2: ( rule__XAnnotationElementValuePair__Group_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0()); 
+            }
+            // InternalOXtype.g:3821:2: ( rule__XAnnotationElementValuePair__Group_0__0 )
+            // InternalOXtype.g:3821:3: rule__XAnnotationElementValuePair__Group_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group__1"
+    // InternalOXtype.g:3829:1: rule__XAnnotationElementValuePair__Group__1 : rule__XAnnotationElementValuePair__Group__1__Impl ;
+    public final void rule__XAnnotationElementValuePair__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3833:1: ( rule__XAnnotationElementValuePair__Group__1__Impl )
+            // InternalOXtype.g:3834:2: rule__XAnnotationElementValuePair__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group__1__Impl"
+    // InternalOXtype.g:3840:1: rule__XAnnotationElementValuePair__Group__1__Impl : ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) ) ;
+    public final void rule__XAnnotationElementValuePair__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3844:1: ( ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) ) )
+            // InternalOXtype.g:3845:1: ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) )
+            {
+            // InternalOXtype.g:3845:1: ( ( rule__XAnnotationElementValuePair__ValueAssignment_1 ) )
+            // InternalOXtype.g:3846:2: ( rule__XAnnotationElementValuePair__ValueAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1()); 
+            }
+            // InternalOXtype.g:3847:2: ( rule__XAnnotationElementValuePair__ValueAssignment_1 )
+            // InternalOXtype.g:3847:3: rule__XAnnotationElementValuePair__ValueAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__ValueAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getValueAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group_0__0"
+    // InternalOXtype.g:3856:1: rule__XAnnotationElementValuePair__Group_0__0 : rule__XAnnotationElementValuePair__Group_0__0__Impl ;
+    public final void rule__XAnnotationElementValuePair__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3860:1: ( rule__XAnnotationElementValuePair__Group_0__0__Impl )
+            // InternalOXtype.g:3861:2: rule__XAnnotationElementValuePair__Group_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group_0__0__Impl"
+    // InternalOXtype.g:3867:1: rule__XAnnotationElementValuePair__Group_0__0__Impl : ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) ) ;
+    public final void rule__XAnnotationElementValuePair__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3871:1: ( ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) ) )
+            // InternalOXtype.g:3872:1: ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:3872:1: ( ( rule__XAnnotationElementValuePair__Group_0_0__0 ) )
+            // InternalOXtype.g:3873:2: ( rule__XAnnotationElementValuePair__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:3874:2: ( rule__XAnnotationElementValuePair__Group_0_0__0 )
+            // InternalOXtype.g:3874:3: rule__XAnnotationElementValuePair__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__0"
+    // InternalOXtype.g:3883:1: rule__XAnnotationElementValuePair__Group_0_0__0 : rule__XAnnotationElementValuePair__Group_0_0__0__Impl rule__XAnnotationElementValuePair__Group_0_0__1 ;
+    public final void rule__XAnnotationElementValuePair__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3887:1: ( rule__XAnnotationElementValuePair__Group_0_0__0__Impl rule__XAnnotationElementValuePair__Group_0_0__1 )
+            // InternalOXtype.g:3888:2: rule__XAnnotationElementValuePair__Group_0_0__0__Impl rule__XAnnotationElementValuePair__Group_0_0__1
+            {
+            pushFollow(FOLLOW_16);
+            rule__XAnnotationElementValuePair__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__0__Impl"
+    // InternalOXtype.g:3895:1: rule__XAnnotationElementValuePair__Group_0_0__0__Impl : ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) ) ;
+    public final void rule__XAnnotationElementValuePair__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3899:1: ( ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) ) )
+            // InternalOXtype.g:3900:1: ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) )
+            {
+            // InternalOXtype.g:3900:1: ( ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 ) )
+            // InternalOXtype.g:3901:2: ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0()); 
+            }
+            // InternalOXtype.g:3902:2: ( rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 )
+            // InternalOXtype.g:3902:3: rule__XAnnotationElementValuePair__ElementAssignment_0_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__ElementAssignment_0_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getElementAssignment_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__1"
+    // InternalOXtype.g:3910:1: rule__XAnnotationElementValuePair__Group_0_0__1 : rule__XAnnotationElementValuePair__Group_0_0__1__Impl ;
+    public final void rule__XAnnotationElementValuePair__Group_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3914:1: ( rule__XAnnotationElementValuePair__Group_0_0__1__Impl )
+            // InternalOXtype.g:3915:2: rule__XAnnotationElementValuePair__Group_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValuePair__Group_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__Group_0_0__1__Impl"
+    // InternalOXtype.g:3921:1: rule__XAnnotationElementValuePair__Group_0_0__1__Impl : ( '=' ) ;
+    public final void rule__XAnnotationElementValuePair__Group_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3925:1: ( ( '=' ) )
+            // InternalOXtype.g:3926:1: ( '=' )
+            {
+            // InternalOXtype.g:3926:1: ( '=' )
+            // InternalOXtype.g:3927:2: '='
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1()); 
+            }
+            match(input,13,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__Group_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__0"
+    // InternalOXtype.g:3937:1: rule__XAnnotationElementValueOrCommaList__Group_0__0 : rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3941:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0__1 )
+            // InternalOXtype.g:3942:2: rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0__1
+            {
+            pushFollow(FOLLOW_17);
+            rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl"
+    // InternalOXtype.g:3949:1: rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3953:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) ) )
+            // InternalOXtype.g:3954:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:3954:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 ) )
+            // InternalOXtype.g:3955:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:3956:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0 )
+            // InternalOXtype.g:3956:3: rule__XAnnotationElementValueOrCommaList__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__1"
+    // InternalOXtype.g:3964:1: rule__XAnnotationElementValueOrCommaList__Group_0__1 : rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0__2 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3968:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0__2 )
+            // InternalOXtype.g:3969:2: rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0__2
+            {
+            pushFollow(FOLLOW_17);
+            rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl"
+    // InternalOXtype.g:3976:1: rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3980:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? ) )
+            // InternalOXtype.g:3981:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? )
+            {
+            // InternalOXtype.g:3981:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )? )
+            // InternalOXtype.g:3982:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1()); 
+            }
+            // InternalOXtype.g:3983:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0 )?
+            int alt50=2;
+            int LA50_0 = input.LA(1);
+
+            if ( ((LA50_0>=RULE_ID && LA50_0<=RULE_STRING)||LA50_0==27||(LA50_0>=34 && LA50_0<=35)||LA50_0==40||(LA50_0>=45 && LA50_0<=50)||(LA50_0>=52 && LA50_0<=53)||(LA50_0>=57 && LA50_0<=58)||LA50_0==61||LA50_0==63||LA50_0==65||(LA50_0>=69 && LA50_0<=77)||LA50_0==79||LA50_0==88) ) {
+                alt50=1;
+            }
+            switch (alt50) {
+                case 1 :
+                    // InternalOXtype.g:3983:3: rule__XAnnotationElementValueOrCommaList__Group_0_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotationElementValueOrCommaList__Group_0_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__2"
+    // InternalOXtype.g:3991:1: rule__XAnnotationElementValueOrCommaList__Group_0__2 : rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:3995:1: ( rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl )
+            // InternalOXtype.g:3996:2: rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__2"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl"
+    // InternalOXtype.g:4002:1: rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl : ( ']' ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4006:1: ( ( ']' ) )
+            // InternalOXtype.g:4007:1: ( ']' )
+            {
+            // InternalOXtype.g:4007:1: ( ']' )
+            // InternalOXtype.g:4008:2: ']'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2()); 
+            }
+            match(input,56,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0__2__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0__0"
+    // InternalOXtype.g:4018:1: rule__XAnnotationElementValueOrCommaList__Group_0_0__0 : rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4022:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl )
+            // InternalOXtype.g:4023:2: rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl"
+    // InternalOXtype.g:4029:1: rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4033:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) ) )
+            // InternalOXtype.g:4034:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) )
+            {
+            // InternalOXtype.g:4034:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 ) )
+            // InternalOXtype.g:4035:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0()); 
+            }
+            // InternalOXtype.g:4036:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 )
+            // InternalOXtype.g:4036:3: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0"
+    // InternalOXtype.g:4045:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0 : rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4049:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1 )
+            // InternalOXtype.g:4050:2: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1
+            {
+            pushFollow(FOLLOW_18);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl"
+    // InternalOXtype.g:4057:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl : ( () ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4061:1: ( ( () ) )
+            // InternalOXtype.g:4062:1: ( () )
+            {
+            // InternalOXtype.g:4062:1: ( () )
+            // InternalOXtype.g:4063:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0()); 
+            }
+            // InternalOXtype.g:4064:2: ()
+            // InternalOXtype.g:4064:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1"
+    // InternalOXtype.g:4072:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1 : rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4076:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2 )
+            // InternalOXtype.g:4077:2: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2
+            {
+            pushFollow(FOLLOW_19);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl"
+    // InternalOXtype.g:4084:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl : ( '#' ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4088:1: ( ( '#' ) )
+            // InternalOXtype.g:4089:1: ( '#' )
+            {
+            // InternalOXtype.g:4089:1: ( '#' )
+            // InternalOXtype.g:4090:2: '#'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1()); 
+            }
+            match(input,57,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2"
+    // InternalOXtype.g:4099:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2 : rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4103:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl )
+            // InternalOXtype.g:4104:2: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl"
+    // InternalOXtype.g:4110:1: rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl : ( '[' ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4114:1: ( ( '[' ) )
+            // InternalOXtype.g:4115:1: ( '[' )
+            {
+            // InternalOXtype.g:4115:1: ( '[' )
+            // InternalOXtype.g:4116:2: '['
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2()); 
+            }
+            match(input,58,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__0"
+    // InternalOXtype.g:4126:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__0 : rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4130:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1__1 )
+            // InternalOXtype.g:4131:2: rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl"
+    // InternalOXtype.g:4138:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl : ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4142:1: ( ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) ) )
+            // InternalOXtype.g:4143:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) )
+            {
+            // InternalOXtype.g:4143:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 ) )
+            // InternalOXtype.g:4144:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0()); 
+            }
+            // InternalOXtype.g:4145:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 )
+            // InternalOXtype.g:4145:3: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__1"
+    // InternalOXtype.g:4153:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__1 : rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4157:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl )
+            // InternalOXtype.g:4158:2: rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl"
+    // InternalOXtype.g:4164:1: rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4168:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* ) )
+            // InternalOXtype.g:4169:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* )
+            {
+            // InternalOXtype.g:4169:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )* )
+            // InternalOXtype.g:4170:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1()); 
+            }
+            // InternalOXtype.g:4171:2: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 )*
+            loop51:
+            do {
+                int alt51=2;
+                int LA51_0 = input.LA(1);
+
+                if ( (LA51_0==55) ) {
+                    alt51=1;
+                }
+
+
+                switch (alt51) {
+            	case 1 :
+            	    // InternalOXtype.g:4171:3: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop51;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0"
+    // InternalOXtype.g:4180:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0 : rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4184:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1 )
+            // InternalOXtype.g:4185:2: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl"
+    // InternalOXtype.g:4192:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4196:1: ( ( ',' ) )
+            // InternalOXtype.g:4197:1: ( ',' )
+            {
+            // InternalOXtype.g:4197:1: ( ',' )
+            // InternalOXtype.g:4198:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1"
+    // InternalOXtype.g:4207:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1 : rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4211:1: ( rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl )
+            // InternalOXtype.g:4212:2: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl"
+    // InternalOXtype.g:4218:1: rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4222:1: ( ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) ) )
+            // InternalOXtype.g:4223:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) )
+            {
+            // InternalOXtype.g:4223:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 ) )
+            // InternalOXtype.g:4224:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1()); 
+            }
+            // InternalOXtype.g:4225:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 )
+            // InternalOXtype.g:4225:3: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_0_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_0_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__0"
+    // InternalOXtype.g:4234:1: rule__XAnnotationElementValueOrCommaList__Group_1__0 : rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4238:1: ( rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1__1 )
+            // InternalOXtype.g:4239:2: rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl"
+    // InternalOXtype.g:4246:1: rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl : ( ruleXAnnotationOrExpression ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4250:1: ( ( ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:4251:1: ( ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:4251:1: ( ruleXAnnotationOrExpression )
+            // InternalOXtype.g:4252:2: ruleXAnnotationOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__1"
+    // InternalOXtype.g:4261:1: rule__XAnnotationElementValueOrCommaList__Group_1__1 : rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4265:1: ( rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl )
+            // InternalOXtype.g:4266:2: rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl"
+    // InternalOXtype.g:4272:1: rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4276:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? ) )
+            // InternalOXtype.g:4277:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? )
+            {
+            // InternalOXtype.g:4277:1: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )? )
+            // InternalOXtype.g:4278:2: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1()); 
+            }
+            // InternalOXtype.g:4279:2: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0 )?
+            int alt52=2;
+            int LA52_0 = input.LA(1);
+
+            if ( (LA52_0==55) ) {
+                alt52=1;
+            }
+            switch (alt52) {
+                case 1 :
+                    // InternalOXtype.g:4279:3: rule__XAnnotationElementValueOrCommaList__Group_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotationElementValueOrCommaList__Group_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__0"
+    // InternalOXtype.g:4288:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__0 : rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4292:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1__1 )
+            // InternalOXtype.g:4293:2: rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl"
+    // InternalOXtype.g:4300:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl : ( () ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4304:1: ( ( () ) )
+            // InternalOXtype.g:4305:1: ( () )
+            {
+            // InternalOXtype.g:4305:1: ( () )
+            // InternalOXtype.g:4306:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()); 
+            }
+            // InternalOXtype.g:4307:2: ()
+            // InternalOXtype.g:4307:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__1"
+    // InternalOXtype.g:4315:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__1 : rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4319:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl )
+            // InternalOXtype.g:4320:2: rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl"
+    // InternalOXtype.g:4326:1: rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl : ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4330:1: ( ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) ) )
+            // InternalOXtype.g:4331:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) )
+            {
+            // InternalOXtype.g:4331:1: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* ) )
+            // InternalOXtype.g:4332:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) ) ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* )
+            {
+            // InternalOXtype.g:4332:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 ) )
+            // InternalOXtype.g:4333:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); 
+            }
+            // InternalOXtype.g:4334:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )
+            // InternalOXtype.g:4334:4: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0
+            {
+            pushFollow(FOLLOW_14);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); 
+            }
+
+            }
+
+            // InternalOXtype.g:4337:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )* )
+            // InternalOXtype.g:4338:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); 
+            }
+            // InternalOXtype.g:4339:3: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 )*
+            loop53:
+            do {
+                int alt53=2;
+                int LA53_0 = input.LA(1);
+
+                if ( (LA53_0==55) ) {
+                    alt53=1;
+                }
+
+
+                switch (alt53) {
+            	case 1 :
+            	    // InternalOXtype.g:4339:4: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop53;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0"
+    // InternalOXtype.g:4349:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0 : rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1 ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4353:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1 )
+            // InternalOXtype.g:4354:2: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl"
+    // InternalOXtype.g:4361:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4365:1: ( ( ',' ) )
+            // InternalOXtype.g:4366:1: ( ',' )
+            {
+            // InternalOXtype.g:4366:1: ( ',' )
+            // InternalOXtype.g:4367:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1"
+    // InternalOXtype.g:4376:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1 : rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4380:1: ( rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl )
+            // InternalOXtype.g:4381:2: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl"
+    // InternalOXtype.g:4387:1: rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl : ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4391:1: ( ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) ) )
+            // InternalOXtype.g:4392:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) )
+            {
+            // InternalOXtype.g:4392:1: ( ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 ) )
+            // InternalOXtype.g:4393:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1()); 
+            }
+            // InternalOXtype.g:4394:2: ( rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 )
+            // InternalOXtype.g:4394:3: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsAssignment_1_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__Group_1_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0__0"
+    // InternalOXtype.g:4403:1: rule__XAnnotationElementValue__Group_0__0 : rule__XAnnotationElementValue__Group_0__0__Impl rule__XAnnotationElementValue__Group_0__1 ;
+    public final void rule__XAnnotationElementValue__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4407:1: ( rule__XAnnotationElementValue__Group_0__0__Impl rule__XAnnotationElementValue__Group_0__1 )
+            // InternalOXtype.g:4408:2: rule__XAnnotationElementValue__Group_0__0__Impl rule__XAnnotationElementValue__Group_0__1
+            {
+            pushFollow(FOLLOW_17);
+            rule__XAnnotationElementValue__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0__0__Impl"
+    // InternalOXtype.g:4415:1: rule__XAnnotationElementValue__Group_0__0__Impl : ( ( rule__XAnnotationElementValue__Group_0_0__0 ) ) ;
+    public final void rule__XAnnotationElementValue__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4419:1: ( ( ( rule__XAnnotationElementValue__Group_0_0__0 ) ) )
+            // InternalOXtype.g:4420:1: ( ( rule__XAnnotationElementValue__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:4420:1: ( ( rule__XAnnotationElementValue__Group_0_0__0 ) )
+            // InternalOXtype.g:4421:2: ( rule__XAnnotationElementValue__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:4422:2: ( rule__XAnnotationElementValue__Group_0_0__0 )
+            // InternalOXtype.g:4422:3: rule__XAnnotationElementValue__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0__1"
+    // InternalOXtype.g:4430:1: rule__XAnnotationElementValue__Group_0__1 : rule__XAnnotationElementValue__Group_0__1__Impl rule__XAnnotationElementValue__Group_0__2 ;
+    public final void rule__XAnnotationElementValue__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4434:1: ( rule__XAnnotationElementValue__Group_0__1__Impl rule__XAnnotationElementValue__Group_0__2 )
+            // InternalOXtype.g:4435:2: rule__XAnnotationElementValue__Group_0__1__Impl rule__XAnnotationElementValue__Group_0__2
+            {
+            pushFollow(FOLLOW_17);
+            rule__XAnnotationElementValue__Group_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0__1__Impl"
+    // InternalOXtype.g:4442:1: rule__XAnnotationElementValue__Group_0__1__Impl : ( ( rule__XAnnotationElementValue__Group_0_1__0 )? ) ;
+    public final void rule__XAnnotationElementValue__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4446:1: ( ( ( rule__XAnnotationElementValue__Group_0_1__0 )? ) )
+            // InternalOXtype.g:4447:1: ( ( rule__XAnnotationElementValue__Group_0_1__0 )? )
+            {
+            // InternalOXtype.g:4447:1: ( ( rule__XAnnotationElementValue__Group_0_1__0 )? )
+            // InternalOXtype.g:4448:2: ( rule__XAnnotationElementValue__Group_0_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1()); 
+            }
+            // InternalOXtype.g:4449:2: ( rule__XAnnotationElementValue__Group_0_1__0 )?
+            int alt54=2;
+            int LA54_0 = input.LA(1);
+
+            if ( ((LA54_0>=RULE_ID && LA54_0<=RULE_STRING)||LA54_0==27||(LA54_0>=34 && LA54_0<=35)||LA54_0==40||(LA54_0>=45 && LA54_0<=50)||(LA54_0>=52 && LA54_0<=53)||(LA54_0>=57 && LA54_0<=58)||LA54_0==61||LA54_0==63||LA54_0==65||(LA54_0>=69 && LA54_0<=77)||LA54_0==79||LA54_0==88) ) {
+                alt54=1;
+            }
+            switch (alt54) {
+                case 1 :
+                    // InternalOXtype.g:4449:3: rule__XAnnotationElementValue__Group_0_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAnnotationElementValue__Group_0_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0__2"
+    // InternalOXtype.g:4457:1: rule__XAnnotationElementValue__Group_0__2 : rule__XAnnotationElementValue__Group_0__2__Impl ;
+    public final void rule__XAnnotationElementValue__Group_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4461:1: ( rule__XAnnotationElementValue__Group_0__2__Impl )
+            // InternalOXtype.g:4462:2: rule__XAnnotationElementValue__Group_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0__2"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0__2__Impl"
+    // InternalOXtype.g:4468:1: rule__XAnnotationElementValue__Group_0__2__Impl : ( ']' ) ;
+    public final void rule__XAnnotationElementValue__Group_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4472:1: ( ( ']' ) )
+            // InternalOXtype.g:4473:1: ( ']' )
+            {
+            // InternalOXtype.g:4473:1: ( ']' )
+            // InternalOXtype.g:4474:2: ']'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2()); 
+            }
+            match(input,56,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0__2__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0__0"
+    // InternalOXtype.g:4484:1: rule__XAnnotationElementValue__Group_0_0__0 : rule__XAnnotationElementValue__Group_0_0__0__Impl ;
+    public final void rule__XAnnotationElementValue__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4488:1: ( rule__XAnnotationElementValue__Group_0_0__0__Impl )
+            // InternalOXtype.g:4489:2: rule__XAnnotationElementValue__Group_0_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0__0__Impl"
+    // InternalOXtype.g:4495:1: rule__XAnnotationElementValue__Group_0_0__0__Impl : ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) ) ;
+    public final void rule__XAnnotationElementValue__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4499:1: ( ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) ) )
+            // InternalOXtype.g:4500:1: ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) )
+            {
+            // InternalOXtype.g:4500:1: ( ( rule__XAnnotationElementValue__Group_0_0_0__0 ) )
+            // InternalOXtype.g:4501:2: ( rule__XAnnotationElementValue__Group_0_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0()); 
+            }
+            // InternalOXtype.g:4502:2: ( rule__XAnnotationElementValue__Group_0_0_0__0 )
+            // InternalOXtype.g:4502:3: rule__XAnnotationElementValue__Group_0_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__0"
+    // InternalOXtype.g:4511:1: rule__XAnnotationElementValue__Group_0_0_0__0 : rule__XAnnotationElementValue__Group_0_0_0__0__Impl rule__XAnnotationElementValue__Group_0_0_0__1 ;
+    public final void rule__XAnnotationElementValue__Group_0_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4515:1: ( rule__XAnnotationElementValue__Group_0_0_0__0__Impl rule__XAnnotationElementValue__Group_0_0_0__1 )
+            // InternalOXtype.g:4516:2: rule__XAnnotationElementValue__Group_0_0_0__0__Impl rule__XAnnotationElementValue__Group_0_0_0__1
+            {
+            pushFollow(FOLLOW_18);
+            rule__XAnnotationElementValue__Group_0_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__0__Impl"
+    // InternalOXtype.g:4523:1: rule__XAnnotationElementValue__Group_0_0_0__0__Impl : ( () ) ;
+    public final void rule__XAnnotationElementValue__Group_0_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4527:1: ( ( () ) )
+            // InternalOXtype.g:4528:1: ( () )
+            {
+            // InternalOXtype.g:4528:1: ( () )
+            // InternalOXtype.g:4529:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0()); 
+            }
+            // InternalOXtype.g:4530:2: ()
+            // InternalOXtype.g:4530:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__1"
+    // InternalOXtype.g:4538:1: rule__XAnnotationElementValue__Group_0_0_0__1 : rule__XAnnotationElementValue__Group_0_0_0__1__Impl rule__XAnnotationElementValue__Group_0_0_0__2 ;
+    public final void rule__XAnnotationElementValue__Group_0_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4542:1: ( rule__XAnnotationElementValue__Group_0_0_0__1__Impl rule__XAnnotationElementValue__Group_0_0_0__2 )
+            // InternalOXtype.g:4543:2: rule__XAnnotationElementValue__Group_0_0_0__1__Impl rule__XAnnotationElementValue__Group_0_0_0__2
+            {
+            pushFollow(FOLLOW_19);
+            rule__XAnnotationElementValue__Group_0_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__1__Impl"
+    // InternalOXtype.g:4550:1: rule__XAnnotationElementValue__Group_0_0_0__1__Impl : ( '#' ) ;
+    public final void rule__XAnnotationElementValue__Group_0_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4554:1: ( ( '#' ) )
+            // InternalOXtype.g:4555:1: ( '#' )
+            {
+            // InternalOXtype.g:4555:1: ( '#' )
+            // InternalOXtype.g:4556:2: '#'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1()); 
+            }
+            match(input,57,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__2"
+    // InternalOXtype.g:4565:1: rule__XAnnotationElementValue__Group_0_0_0__2 : rule__XAnnotationElementValue__Group_0_0_0__2__Impl ;
+    public final void rule__XAnnotationElementValue__Group_0_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4569:1: ( rule__XAnnotationElementValue__Group_0_0_0__2__Impl )
+            // InternalOXtype.g:4570:2: rule__XAnnotationElementValue__Group_0_0_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__2"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_0_0__2__Impl"
+    // InternalOXtype.g:4576:1: rule__XAnnotationElementValue__Group_0_0_0__2__Impl : ( '[' ) ;
+    public final void rule__XAnnotationElementValue__Group_0_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4580:1: ( ( '[' ) )
+            // InternalOXtype.g:4581:1: ( '[' )
+            {
+            // InternalOXtype.g:4581:1: ( '[' )
+            // InternalOXtype.g:4582:2: '['
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2()); 
+            }
+            match(input,58,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__0"
+    // InternalOXtype.g:4592:1: rule__XAnnotationElementValue__Group_0_1__0 : rule__XAnnotationElementValue__Group_0_1__0__Impl rule__XAnnotationElementValue__Group_0_1__1 ;
+    public final void rule__XAnnotationElementValue__Group_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4596:1: ( rule__XAnnotationElementValue__Group_0_1__0__Impl rule__XAnnotationElementValue__Group_0_1__1 )
+            // InternalOXtype.g:4597:2: rule__XAnnotationElementValue__Group_0_1__0__Impl rule__XAnnotationElementValue__Group_0_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XAnnotationElementValue__Group_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__0__Impl"
+    // InternalOXtype.g:4604:1: rule__XAnnotationElementValue__Group_0_1__0__Impl : ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) ) ;
+    public final void rule__XAnnotationElementValue__Group_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4608:1: ( ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) ) )
+            // InternalOXtype.g:4609:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) )
+            {
+            // InternalOXtype.g:4609:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 ) )
+            // InternalOXtype.g:4610:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0()); 
+            }
+            // InternalOXtype.g:4611:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_0 )
+            // InternalOXtype.g:4611:3: rule__XAnnotationElementValue__ElementsAssignment_0_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__ElementsAssignment_0_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__1"
+    // InternalOXtype.g:4619:1: rule__XAnnotationElementValue__Group_0_1__1 : rule__XAnnotationElementValue__Group_0_1__1__Impl ;
+    public final void rule__XAnnotationElementValue__Group_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4623:1: ( rule__XAnnotationElementValue__Group_0_1__1__Impl )
+            // InternalOXtype.g:4624:2: rule__XAnnotationElementValue__Group_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1__1__Impl"
+    // InternalOXtype.g:4630:1: rule__XAnnotationElementValue__Group_0_1__1__Impl : ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* ) ;
+    public final void rule__XAnnotationElementValue__Group_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4634:1: ( ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* ) )
+            // InternalOXtype.g:4635:1: ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* )
+            {
+            // InternalOXtype.g:4635:1: ( ( rule__XAnnotationElementValue__Group_0_1_1__0 )* )
+            // InternalOXtype.g:4636:2: ( rule__XAnnotationElementValue__Group_0_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1()); 
+            }
+            // InternalOXtype.g:4637:2: ( rule__XAnnotationElementValue__Group_0_1_1__0 )*
+            loop55:
+            do {
+                int alt55=2;
+                int LA55_0 = input.LA(1);
+
+                if ( (LA55_0==55) ) {
+                    alt55=1;
+                }
+
+
+                switch (alt55) {
+            	case 1 :
+            	    // InternalOXtype.g:4637:3: rule__XAnnotationElementValue__Group_0_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XAnnotationElementValue__Group_0_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop55;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getGroup_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__0"
+    // InternalOXtype.g:4646:1: rule__XAnnotationElementValue__Group_0_1_1__0 : rule__XAnnotationElementValue__Group_0_1_1__0__Impl rule__XAnnotationElementValue__Group_0_1_1__1 ;
+    public final void rule__XAnnotationElementValue__Group_0_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4650:1: ( rule__XAnnotationElementValue__Group_0_1_1__0__Impl rule__XAnnotationElementValue__Group_0_1_1__1 )
+            // InternalOXtype.g:4651:2: rule__XAnnotationElementValue__Group_0_1_1__0__Impl rule__XAnnotationElementValue__Group_0_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAnnotationElementValue__Group_0_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__0__Impl"
+    // InternalOXtype.g:4658:1: rule__XAnnotationElementValue__Group_0_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XAnnotationElementValue__Group_0_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4662:1: ( ( ',' ) )
+            // InternalOXtype.g:4663:1: ( ',' )
+            {
+            // InternalOXtype.g:4663:1: ( ',' )
+            // InternalOXtype.g:4664:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__1"
+    // InternalOXtype.g:4673:1: rule__XAnnotationElementValue__Group_0_1_1__1 : rule__XAnnotationElementValue__Group_0_1_1__1__Impl ;
+    public final void rule__XAnnotationElementValue__Group_0_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4677:1: ( rule__XAnnotationElementValue__Group_0_1_1__1__Impl )
+            // InternalOXtype.g:4678:2: rule__XAnnotationElementValue__Group_0_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__Group_0_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__Group_0_1_1__1__Impl"
+    // InternalOXtype.g:4684:1: rule__XAnnotationElementValue__Group_0_1_1__1__Impl : ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) ) ;
+    public final void rule__XAnnotationElementValue__Group_0_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4688:1: ( ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) ) )
+            // InternalOXtype.g:4689:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) )
+            {
+            // InternalOXtype.g:4689:1: ( ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 ) )
+            // InternalOXtype.g:4690:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1()); 
+            }
+            // InternalOXtype.g:4691:2: ( rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 )
+            // InternalOXtype.g:4691:3: rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getElementsAssignment_0_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__Group_0_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__0"
+    // InternalOXtype.g:4700:1: rule__XAssignment__Group_0__0 : rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 ;
+    public final void rule__XAssignment__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4704:1: ( rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1 )
+            // InternalOXtype.g:4705:2: rule__XAssignment__Group_0__0__Impl rule__XAssignment__Group_0__1
+            {
+            pushFollow(FOLLOW_20);
+            rule__XAssignment__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__0"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__0__Impl"
+    // InternalOXtype.g:4712:1: rule__XAssignment__Group_0__0__Impl : ( () ) ;
+    public final void rule__XAssignment__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4716:1: ( ( () ) )
+            // InternalOXtype.g:4717:1: ( () )
+            {
+            // InternalOXtype.g:4717:1: ( () )
+            // InternalOXtype.g:4718:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); 
+            }
+            // InternalOXtype.g:4719:2: ()
+            // InternalOXtype.g:4719:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__1"
+    // InternalOXtype.g:4727:1: rule__XAssignment__Group_0__1 : rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 ;
+    public final void rule__XAssignment__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4731:1: ( rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2 )
+            // InternalOXtype.g:4732:2: rule__XAssignment__Group_0__1__Impl rule__XAssignment__Group_0__2
+            {
+            pushFollow(FOLLOW_16);
+            rule__XAssignment__Group_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__1"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__1__Impl"
+    // InternalOXtype.g:4739:1: rule__XAssignment__Group_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) ;
+    public final void rule__XAssignment__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4743:1: ( ( ( rule__XAssignment__FeatureAssignment_0_1 ) ) )
+            // InternalOXtype.g:4744:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) )
+            {
+            // InternalOXtype.g:4744:1: ( ( rule__XAssignment__FeatureAssignment_0_1 ) )
+            // InternalOXtype.g:4745:2: ( rule__XAssignment__FeatureAssignment_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); 
+            }
+            // InternalOXtype.g:4746:2: ( rule__XAssignment__FeatureAssignment_0_1 )
+            // InternalOXtype.g:4746:3: rule__XAssignment__FeatureAssignment_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__FeatureAssignment_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__2"
+    // InternalOXtype.g:4754:1: rule__XAssignment__Group_0__2 : rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 ;
+    public final void rule__XAssignment__Group_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4758:1: ( rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3 )
+            // InternalOXtype.g:4759:2: rule__XAssignment__Group_0__2__Impl rule__XAssignment__Group_0__3
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAssignment__Group_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_0__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__2"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__2__Impl"
+    // InternalOXtype.g:4766:1: rule__XAssignment__Group_0__2__Impl : ( ruleOpSingleAssign ) ;
+    public final void rule__XAssignment__Group_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4770:1: ( ( ruleOpSingleAssign ) )
+            // InternalOXtype.g:4771:1: ( ruleOpSingleAssign )
+            {
+            // InternalOXtype.g:4771:1: ( ruleOpSingleAssign )
+            // InternalOXtype.g:4772:2: ruleOpSingleAssign
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpSingleAssign();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__2__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__3"
+    // InternalOXtype.g:4781:1: rule__XAssignment__Group_0__3 : rule__XAssignment__Group_0__3__Impl ;
+    public final void rule__XAssignment__Group_0__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4785:1: ( rule__XAssignment__Group_0__3__Impl )
+            // InternalOXtype.g:4786:2: rule__XAssignment__Group_0__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_0__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__3"
+
+
+    // $ANTLR start "rule__XAssignment__Group_0__3__Impl"
+    // InternalOXtype.g:4792:1: rule__XAssignment__Group_0__3__Impl : ( ( rule__XAssignment__ValueAssignment_0_3 ) ) ;
+    public final void rule__XAssignment__Group_0__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4796:1: ( ( ( rule__XAssignment__ValueAssignment_0_3 ) ) )
+            // InternalOXtype.g:4797:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) )
+            {
+            // InternalOXtype.g:4797:1: ( ( rule__XAssignment__ValueAssignment_0_3 ) )
+            // InternalOXtype.g:4798:2: ( rule__XAssignment__ValueAssignment_0_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); 
+            }
+            // InternalOXtype.g:4799:2: ( rule__XAssignment__ValueAssignment_0_3 )
+            // InternalOXtype.g:4799:3: rule__XAssignment__ValueAssignment_0_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__ValueAssignment_0_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getValueAssignment_0_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_0__3__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1__0"
+    // InternalOXtype.g:4808:1: rule__XAssignment__Group_1__0 : rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 ;
+    public final void rule__XAssignment__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4812:1: ( rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1 )
+            // InternalOXtype.g:4813:2: rule__XAssignment__Group_1__0__Impl rule__XAssignment__Group_1__1
+            {
+            pushFollow(FOLLOW_21);
+            rule__XAssignment__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1__0"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1__0__Impl"
+    // InternalOXtype.g:4820:1: rule__XAssignment__Group_1__0__Impl : ( ruleXOrExpression ) ;
+    public final void rule__XAssignment__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4824:1: ( ( ruleXOrExpression ) )
+            // InternalOXtype.g:4825:1: ( ruleXOrExpression )
+            {
+            // InternalOXtype.g:4825:1: ( ruleXOrExpression )
+            // InternalOXtype.g:4826:2: ruleXOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1__1"
+    // InternalOXtype.g:4835:1: rule__XAssignment__Group_1__1 : rule__XAssignment__Group_1__1__Impl ;
+    public final void rule__XAssignment__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4839:1: ( rule__XAssignment__Group_1__1__Impl )
+            // InternalOXtype.g:4840:2: rule__XAssignment__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1__1"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1__1__Impl"
+    // InternalOXtype.g:4846:1: rule__XAssignment__Group_1__1__Impl : ( ( rule__XAssignment__Group_1_1__0 )? ) ;
+    public final void rule__XAssignment__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4850:1: ( ( ( rule__XAssignment__Group_1_1__0 )? ) )
+            // InternalOXtype.g:4851:1: ( ( rule__XAssignment__Group_1_1__0 )? )
+            {
+            // InternalOXtype.g:4851:1: ( ( rule__XAssignment__Group_1_1__0 )? )
+            // InternalOXtype.g:4852:2: ( rule__XAssignment__Group_1_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getGroup_1_1()); 
+            }
+            // InternalOXtype.g:4853:2: ( rule__XAssignment__Group_1_1__0 )?
+            int alt56=2;
+            alt56 = dfa56.predict(input);
+            switch (alt56) {
+                case 1 :
+                    // InternalOXtype.g:4853:3: rule__XAssignment__Group_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XAssignment__Group_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getGroup_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1__0"
+    // InternalOXtype.g:4862:1: rule__XAssignment__Group_1_1__0 : rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 ;
+    public final void rule__XAssignment__Group_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4866:1: ( rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1 )
+            // InternalOXtype.g:4867:2: rule__XAssignment__Group_1_1__0__Impl rule__XAssignment__Group_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAssignment__Group_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1__0"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1__0__Impl"
+    // InternalOXtype.g:4874:1: rule__XAssignment__Group_1_1__0__Impl : ( ( rule__XAssignment__Group_1_1_0__0 ) ) ;
+    public final void rule__XAssignment__Group_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4878:1: ( ( ( rule__XAssignment__Group_1_1_0__0 ) ) )
+            // InternalOXtype.g:4879:1: ( ( rule__XAssignment__Group_1_1_0__0 ) )
+            {
+            // InternalOXtype.g:4879:1: ( ( rule__XAssignment__Group_1_1_0__0 ) )
+            // InternalOXtype.g:4880:2: ( rule__XAssignment__Group_1_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); 
+            }
+            // InternalOXtype.g:4881:2: ( rule__XAssignment__Group_1_1_0__0 )
+            // InternalOXtype.g:4881:3: rule__XAssignment__Group_1_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1__1"
+    // InternalOXtype.g:4889:1: rule__XAssignment__Group_1_1__1 : rule__XAssignment__Group_1_1__1__Impl ;
+    public final void rule__XAssignment__Group_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4893:1: ( rule__XAssignment__Group_1_1__1__Impl )
+            // InternalOXtype.g:4894:2: rule__XAssignment__Group_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1__1"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1__1__Impl"
+    // InternalOXtype.g:4900:1: rule__XAssignment__Group_1_1__1__Impl : ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) ;
+    public final void rule__XAssignment__Group_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4904:1: ( ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) ) )
+            // InternalOXtype.g:4905:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) )
+            {
+            // InternalOXtype.g:4905:1: ( ( rule__XAssignment__RightOperandAssignment_1_1_1 ) )
+            // InternalOXtype.g:4906:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); 
+            }
+            // InternalOXtype.g:4907:2: ( rule__XAssignment__RightOperandAssignment_1_1_1 )
+            // InternalOXtype.g:4907:3: rule__XAssignment__RightOperandAssignment_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__RightOperandAssignment_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getRightOperandAssignment_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1_0__0"
+    // InternalOXtype.g:4916:1: rule__XAssignment__Group_1_1_0__0 : rule__XAssignment__Group_1_1_0__0__Impl ;
+    public final void rule__XAssignment__Group_1_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4920:1: ( rule__XAssignment__Group_1_1_0__0__Impl )
+            // InternalOXtype.g:4921:2: rule__XAssignment__Group_1_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1_0__0"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1_0__0__Impl"
+    // InternalOXtype.g:4927:1: rule__XAssignment__Group_1_1_0__0__Impl : ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) ;
+    public final void rule__XAssignment__Group_1_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4931:1: ( ( ( rule__XAssignment__Group_1_1_0_0__0 ) ) )
+            // InternalOXtype.g:4932:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:4932:1: ( ( rule__XAssignment__Group_1_1_0_0__0 ) )
+            // InternalOXtype.g:4933:2: ( rule__XAssignment__Group_1_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); 
+            }
+            // InternalOXtype.g:4934:2: ( rule__XAssignment__Group_1_1_0_0__0 )
+            // InternalOXtype.g:4934:3: rule__XAssignment__Group_1_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getGroup_1_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0"
+    // InternalOXtype.g:4943:1: rule__XAssignment__Group_1_1_0_0__0 : rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 ;
+    public final void rule__XAssignment__Group_1_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4947:1: ( rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1 )
+            // InternalOXtype.g:4948:2: rule__XAssignment__Group_1_1_0_0__0__Impl rule__XAssignment__Group_1_1_0_0__1
+            {
+            pushFollow(FOLLOW_21);
+            rule__XAssignment__Group_1_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1_0_0__0__Impl"
+    // InternalOXtype.g:4955:1: rule__XAssignment__Group_1_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XAssignment__Group_1_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4959:1: ( ( () ) )
+            // InternalOXtype.g:4960:1: ( () )
+            {
+            // InternalOXtype.g:4960:1: ( () )
+            // InternalOXtype.g:4961:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); 
+            }
+            // InternalOXtype.g:4962:2: ()
+            // InternalOXtype.g:4962:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1"
+    // InternalOXtype.g:4970:1: rule__XAssignment__Group_1_1_0_0__1 : rule__XAssignment__Group_1_1_0_0__1__Impl ;
+    public final void rule__XAssignment__Group_1_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4974:1: ( rule__XAssignment__Group_1_1_0_0__1__Impl )
+            // InternalOXtype.g:4975:2: rule__XAssignment__Group_1_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__Group_1_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1"
+
+
+    // $ANTLR start "rule__XAssignment__Group_1_1_0_0__1__Impl"
+    // InternalOXtype.g:4981:1: rule__XAssignment__Group_1_1_0_0__1__Impl : ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) ;
+    public final void rule__XAssignment__Group_1_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:4985:1: ( ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) ) )
+            // InternalOXtype.g:4986:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:4986:1: ( ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 ) )
+            // InternalOXtype.g:4987:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); 
+            }
+            // InternalOXtype.g:4988:2: ( rule__XAssignment__FeatureAssignment_1_1_0_0_1 )
+            // InternalOXtype.g:4988:3: rule__XAssignment__FeatureAssignment_1_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAssignment__FeatureAssignment_1_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getFeatureAssignment_1_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__Group_1_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_5__0"
+    // InternalOXtype.g:4997:1: rule__OpMultiAssign__Group_5__0 : rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 ;
+    public final void rule__OpMultiAssign__Group_5__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5001:1: ( rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1 )
+            // InternalOXtype.g:5002:2: rule__OpMultiAssign__Group_5__0__Impl rule__OpMultiAssign__Group_5__1
+            {
+            pushFollow(FOLLOW_22);
+            rule__OpMultiAssign__Group_5__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Group_5__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_5__0"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_5__0__Impl"
+    // InternalOXtype.g:5009:1: rule__OpMultiAssign__Group_5__0__Impl : ( '<' ) ;
+    public final void rule__OpMultiAssign__Group_5__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5013:1: ( ( '<' ) )
+            // InternalOXtype.g:5014:1: ( '<' )
+            {
+            // InternalOXtype.g:5014:1: ( '<' )
+            // InternalOXtype.g:5015:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_5__0__Impl"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_5__1"
+    // InternalOXtype.g:5024:1: rule__OpMultiAssign__Group_5__1 : rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 ;
+    public final void rule__OpMultiAssign__Group_5__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5028:1: ( rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2 )
+            // InternalOXtype.g:5029:2: rule__OpMultiAssign__Group_5__1__Impl rule__OpMultiAssign__Group_5__2
+            {
+            pushFollow(FOLLOW_16);
+            rule__OpMultiAssign__Group_5__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Group_5__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_5__1"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_5__1__Impl"
+    // InternalOXtype.g:5036:1: rule__OpMultiAssign__Group_5__1__Impl : ( '<' ) ;
+    public final void rule__OpMultiAssign__Group_5__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5040:1: ( ( '<' ) )
+            // InternalOXtype.g:5041:1: ( '<' )
+            {
+            // InternalOXtype.g:5041:1: ( '<' )
+            // InternalOXtype.g:5042:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_5__1__Impl"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_5__2"
+    // InternalOXtype.g:5051:1: rule__OpMultiAssign__Group_5__2 : rule__OpMultiAssign__Group_5__2__Impl ;
+    public final void rule__OpMultiAssign__Group_5__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5055:1: ( rule__OpMultiAssign__Group_5__2__Impl )
+            // InternalOXtype.g:5056:2: rule__OpMultiAssign__Group_5__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Group_5__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_5__2"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_5__2__Impl"
+    // InternalOXtype.g:5062:1: rule__OpMultiAssign__Group_5__2__Impl : ( '=' ) ;
+    public final void rule__OpMultiAssign__Group_5__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5066:1: ( ( '=' ) )
+            // InternalOXtype.g:5067:1: ( '=' )
+            {
+            // InternalOXtype.g:5067:1: ( '=' )
+            // InternalOXtype.g:5068:2: '='
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); 
+            }
+            match(input,13,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_5__2__Impl"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_6__0"
+    // InternalOXtype.g:5078:1: rule__OpMultiAssign__Group_6__0 : rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 ;
+    public final void rule__OpMultiAssign__Group_6__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5082:1: ( rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1 )
+            // InternalOXtype.g:5083:2: rule__OpMultiAssign__Group_6__0__Impl rule__OpMultiAssign__Group_6__1
+            {
+            pushFollow(FOLLOW_23);
+            rule__OpMultiAssign__Group_6__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Group_6__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_6__0"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_6__0__Impl"
+    // InternalOXtype.g:5090:1: rule__OpMultiAssign__Group_6__0__Impl : ( '>' ) ;
+    public final void rule__OpMultiAssign__Group_6__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5094:1: ( ( '>' ) )
+            // InternalOXtype.g:5095:1: ( '>' )
+            {
+            // InternalOXtype.g:5095:1: ( '>' )
+            // InternalOXtype.g:5096:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_6__0__Impl"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_6__1"
+    // InternalOXtype.g:5105:1: rule__OpMultiAssign__Group_6__1 : rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 ;
+    public final void rule__OpMultiAssign__Group_6__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5109:1: ( rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2 )
+            // InternalOXtype.g:5110:2: rule__OpMultiAssign__Group_6__1__Impl rule__OpMultiAssign__Group_6__2
+            {
+            pushFollow(FOLLOW_23);
+            rule__OpMultiAssign__Group_6__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Group_6__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_6__1"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_6__1__Impl"
+    // InternalOXtype.g:5117:1: rule__OpMultiAssign__Group_6__1__Impl : ( ( '>' )? ) ;
+    public final void rule__OpMultiAssign__Group_6__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5121:1: ( ( ( '>' )? ) )
+            // InternalOXtype.g:5122:1: ( ( '>' )? )
+            {
+            // InternalOXtype.g:5122:1: ( ( '>' )? )
+            // InternalOXtype.g:5123:2: ( '>' )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); 
+            }
+            // InternalOXtype.g:5124:2: ( '>' )?
+            int alt57=2;
+            int LA57_0 = input.LA(1);
+
+            if ( (LA57_0==26) ) {
+                alt57=1;
+            }
+            switch (alt57) {
+                case 1 :
+                    // InternalOXtype.g:5124:3: '>'
+                    {
+                    match(input,26,FOLLOW_2); if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_6__1__Impl"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_6__2"
+    // InternalOXtype.g:5132:1: rule__OpMultiAssign__Group_6__2 : rule__OpMultiAssign__Group_6__2__Impl ;
+    public final void rule__OpMultiAssign__Group_6__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5136:1: ( rule__OpMultiAssign__Group_6__2__Impl )
+            // InternalOXtype.g:5137:2: rule__OpMultiAssign__Group_6__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpMultiAssign__Group_6__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_6__2"
+
+
+    // $ANTLR start "rule__OpMultiAssign__Group_6__2__Impl"
+    // InternalOXtype.g:5143:1: rule__OpMultiAssign__Group_6__2__Impl : ( '>=' ) ;
+    public final void rule__OpMultiAssign__Group_6__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5147:1: ( ( '>=' ) )
+            // InternalOXtype.g:5148:1: ( '>=' )
+            {
+            // InternalOXtype.g:5148:1: ( '>=' )
+            // InternalOXtype.g:5149:2: '>='
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); 
+            }
+            match(input,25,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpMultiAssign__Group_6__2__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group__0"
+    // InternalOXtype.g:5159:1: rule__XOrExpression__Group__0 : rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 ;
+    public final void rule__XOrExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5163:1: ( rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1 )
+            // InternalOXtype.g:5164:2: rule__XOrExpression__Group__0__Impl rule__XOrExpression__Group__1
+            {
+            pushFollow(FOLLOW_24);
+            rule__XOrExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group__0"
+
+
+    // $ANTLR start "rule__XOrExpression__Group__0__Impl"
+    // InternalOXtype.g:5171:1: rule__XOrExpression__Group__0__Impl : ( ruleXAndExpression ) ;
+    public final void rule__XOrExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5175:1: ( ( ruleXAndExpression ) )
+            // InternalOXtype.g:5176:1: ( ruleXAndExpression )
+            {
+            // InternalOXtype.g:5176:1: ( ruleXAndExpression )
+            // InternalOXtype.g:5177:2: ruleXAndExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAndExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group__1"
+    // InternalOXtype.g:5186:1: rule__XOrExpression__Group__1 : rule__XOrExpression__Group__1__Impl ;
+    public final void rule__XOrExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5190:1: ( rule__XOrExpression__Group__1__Impl )
+            // InternalOXtype.g:5191:2: rule__XOrExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group__1"
+
+
+    // $ANTLR start "rule__XOrExpression__Group__1__Impl"
+    // InternalOXtype.g:5197:1: rule__XOrExpression__Group__1__Impl : ( ( rule__XOrExpression__Group_1__0 )* ) ;
+    public final void rule__XOrExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5201:1: ( ( ( rule__XOrExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:5202:1: ( ( rule__XOrExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:5202:1: ( ( rule__XOrExpression__Group_1__0 )* )
+            // InternalOXtype.g:5203:2: ( rule__XOrExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:5204:2: ( rule__XOrExpression__Group_1__0 )*
+            loop58:
+            do {
+                int alt58=2;
+                int LA58_0 = input.LA(1);
+
+                if ( (LA58_0==14) ) {
+                    int LA58_2 = input.LA(2);
+
+                    if ( (synpred102_InternalOXtype()) ) {
+                        alt58=1;
+                    }
+
+
+                }
+
+
+                switch (alt58) {
+            	case 1 :
+            	    // InternalOXtype.g:5204:3: rule__XOrExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_25);
+            	    rule__XOrExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop58;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1__0"
+    // InternalOXtype.g:5213:1: rule__XOrExpression__Group_1__0 : rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 ;
+    public final void rule__XOrExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5217:1: ( rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1 )
+            // InternalOXtype.g:5218:2: rule__XOrExpression__Group_1__0__Impl rule__XOrExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XOrExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1__0__Impl"
+    // InternalOXtype.g:5225:1: rule__XOrExpression__Group_1__0__Impl : ( ( rule__XOrExpression__Group_1_0__0 ) ) ;
+    public final void rule__XOrExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5229:1: ( ( ( rule__XOrExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:5230:1: ( ( rule__XOrExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:5230:1: ( ( rule__XOrExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:5231:2: ( rule__XOrExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:5232:2: ( rule__XOrExpression__Group_1_0__0 )
+            // InternalOXtype.g:5232:3: rule__XOrExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1__1"
+    // InternalOXtype.g:5240:1: rule__XOrExpression__Group_1__1 : rule__XOrExpression__Group_1__1__Impl ;
+    public final void rule__XOrExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5244:1: ( rule__XOrExpression__Group_1__1__Impl )
+            // InternalOXtype.g:5245:2: rule__XOrExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1__1__Impl"
+    // InternalOXtype.g:5251:1: rule__XOrExpression__Group_1__1__Impl : ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) ;
+    public final void rule__XOrExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5255:1: ( ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) ) )
+            // InternalOXtype.g:5256:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:5256:1: ( ( rule__XOrExpression__RightOperandAssignment_1_1 ) )
+            // InternalOXtype.g:5257:2: ( rule__XOrExpression__RightOperandAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+            // InternalOXtype.g:5258:2: ( rule__XOrExpression__RightOperandAssignment_1_1 )
+            // InternalOXtype.g:5258:3: rule__XOrExpression__RightOperandAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__RightOperandAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1_0__0"
+    // InternalOXtype.g:5267:1: rule__XOrExpression__Group_1_0__0 : rule__XOrExpression__Group_1_0__0__Impl ;
+    public final void rule__XOrExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5271:1: ( rule__XOrExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:5272:2: rule__XOrExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:5278:1: rule__XOrExpression__Group_1_0__0__Impl : ( ( rule__XOrExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XOrExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5282:1: ( ( ( rule__XOrExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:5283:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:5283:1: ( ( rule__XOrExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:5284:2: ( rule__XOrExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:5285:2: ( rule__XOrExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:5285:3: rule__XOrExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1_0_0__0"
+    // InternalOXtype.g:5294:1: rule__XOrExpression__Group_1_0_0__0 : rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 ;
+    public final void rule__XOrExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5298:1: ( rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:5299:2: rule__XOrExpression__Group_1_0_0__0__Impl rule__XOrExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_24);
+            rule__XOrExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:5306:1: rule__XOrExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XOrExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5310:1: ( ( () ) )
+            // InternalOXtype.g:5311:1: ( () )
+            {
+            // InternalOXtype.g:5311:1: ( () )
+            // InternalOXtype.g:5312:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:5313:2: ()
+            // InternalOXtype.g:5313:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1_0_0__1"
+    // InternalOXtype.g:5321:1: rule__XOrExpression__Group_1_0_0__1 : rule__XOrExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XOrExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5325:1: ( rule__XOrExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:5326:2: rule__XOrExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XOrExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:5332:1: rule__XOrExpression__Group_1_0_0__1__Impl : ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) ;
+    public final void rule__XOrExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5336:1: ( ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) ) )
+            // InternalOXtype.g:5337:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:5337:1: ( ( rule__XOrExpression__FeatureAssignment_1_0_0_1 ) )
+            // InternalOXtype.g:5338:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+            // InternalOXtype.g:5339:2: ( rule__XOrExpression__FeatureAssignment_1_0_0_1 )
+            // InternalOXtype.g:5339:3: rule__XOrExpression__FeatureAssignment_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOrExpression__FeatureAssignment_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group__0"
+    // InternalOXtype.g:5348:1: rule__XAndExpression__Group__0 : rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 ;
+    public final void rule__XAndExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5352:1: ( rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1 )
+            // InternalOXtype.g:5353:2: rule__XAndExpression__Group__0__Impl rule__XAndExpression__Group__1
+            {
+            pushFollow(FOLLOW_26);
+            rule__XAndExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group__0"
+
+
+    // $ANTLR start "rule__XAndExpression__Group__0__Impl"
+    // InternalOXtype.g:5360:1: rule__XAndExpression__Group__0__Impl : ( ruleXEqualityExpression ) ;
+    public final void rule__XAndExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5364:1: ( ( ruleXEqualityExpression ) )
+            // InternalOXtype.g:5365:1: ( ruleXEqualityExpression )
+            {
+            // InternalOXtype.g:5365:1: ( ruleXEqualityExpression )
+            // InternalOXtype.g:5366:2: ruleXEqualityExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXEqualityExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group__1"
+    // InternalOXtype.g:5375:1: rule__XAndExpression__Group__1 : rule__XAndExpression__Group__1__Impl ;
+    public final void rule__XAndExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5379:1: ( rule__XAndExpression__Group__1__Impl )
+            // InternalOXtype.g:5380:2: rule__XAndExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group__1"
+
+
+    // $ANTLR start "rule__XAndExpression__Group__1__Impl"
+    // InternalOXtype.g:5386:1: rule__XAndExpression__Group__1__Impl : ( ( rule__XAndExpression__Group_1__0 )* ) ;
+    public final void rule__XAndExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5390:1: ( ( ( rule__XAndExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:5391:1: ( ( rule__XAndExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:5391:1: ( ( rule__XAndExpression__Group_1__0 )* )
+            // InternalOXtype.g:5392:2: ( rule__XAndExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:5393:2: ( rule__XAndExpression__Group_1__0 )*
+            loop59:
+            do {
+                int alt59=2;
+                int LA59_0 = input.LA(1);
+
+                if ( (LA59_0==15) ) {
+                    int LA59_2 = input.LA(2);
+
+                    if ( (synpred103_InternalOXtype()) ) {
+                        alt59=1;
+                    }
+
+
+                }
+
+
+                switch (alt59) {
+            	case 1 :
+            	    // InternalOXtype.g:5393:3: rule__XAndExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_27);
+            	    rule__XAndExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop59;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1__0"
+    // InternalOXtype.g:5402:1: rule__XAndExpression__Group_1__0 : rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 ;
+    public final void rule__XAndExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5406:1: ( rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1 )
+            // InternalOXtype.g:5407:2: rule__XAndExpression__Group_1__0__Impl rule__XAndExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAndExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1__0__Impl"
+    // InternalOXtype.g:5414:1: rule__XAndExpression__Group_1__0__Impl : ( ( rule__XAndExpression__Group_1_0__0 ) ) ;
+    public final void rule__XAndExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5418:1: ( ( ( rule__XAndExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:5419:1: ( ( rule__XAndExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:5419:1: ( ( rule__XAndExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:5420:2: ( rule__XAndExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:5421:2: ( rule__XAndExpression__Group_1_0__0 )
+            // InternalOXtype.g:5421:3: rule__XAndExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1__1"
+    // InternalOXtype.g:5429:1: rule__XAndExpression__Group_1__1 : rule__XAndExpression__Group_1__1__Impl ;
+    public final void rule__XAndExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5433:1: ( rule__XAndExpression__Group_1__1__Impl )
+            // InternalOXtype.g:5434:2: rule__XAndExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1__1__Impl"
+    // InternalOXtype.g:5440:1: rule__XAndExpression__Group_1__1__Impl : ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) ;
+    public final void rule__XAndExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5444:1: ( ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) ) )
+            // InternalOXtype.g:5445:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:5445:1: ( ( rule__XAndExpression__RightOperandAssignment_1_1 ) )
+            // InternalOXtype.g:5446:2: ( rule__XAndExpression__RightOperandAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+            // InternalOXtype.g:5447:2: ( rule__XAndExpression__RightOperandAssignment_1_1 )
+            // InternalOXtype.g:5447:3: rule__XAndExpression__RightOperandAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__RightOperandAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1_0__0"
+    // InternalOXtype.g:5456:1: rule__XAndExpression__Group_1_0__0 : rule__XAndExpression__Group_1_0__0__Impl ;
+    public final void rule__XAndExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5460:1: ( rule__XAndExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:5461:2: rule__XAndExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:5467:1: rule__XAndExpression__Group_1_0__0__Impl : ( ( rule__XAndExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XAndExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5471:1: ( ( ( rule__XAndExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:5472:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:5472:1: ( ( rule__XAndExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:5473:2: ( rule__XAndExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:5474:2: ( rule__XAndExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:5474:3: rule__XAndExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1_0_0__0"
+    // InternalOXtype.g:5483:1: rule__XAndExpression__Group_1_0_0__0 : rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 ;
+    public final void rule__XAndExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5487:1: ( rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:5488:2: rule__XAndExpression__Group_1_0_0__0__Impl rule__XAndExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_26);
+            rule__XAndExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:5495:1: rule__XAndExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XAndExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5499:1: ( ( () ) )
+            // InternalOXtype.g:5500:1: ( () )
+            {
+            // InternalOXtype.g:5500:1: ( () )
+            // InternalOXtype.g:5501:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:5502:2: ()
+            // InternalOXtype.g:5502:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1_0_0__1"
+    // InternalOXtype.g:5510:1: rule__XAndExpression__Group_1_0_0__1 : rule__XAndExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XAndExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5514:1: ( rule__XAndExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:5515:2: rule__XAndExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XAndExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:5521:1: rule__XAndExpression__Group_1_0_0__1__Impl : ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) ;
+    public final void rule__XAndExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5525:1: ( ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) ) )
+            // InternalOXtype.g:5526:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:5526:1: ( ( rule__XAndExpression__FeatureAssignment_1_0_0_1 ) )
+            // InternalOXtype.g:5527:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+            // InternalOXtype.g:5528:2: ( rule__XAndExpression__FeatureAssignment_1_0_0_1 )
+            // InternalOXtype.g:5528:3: rule__XAndExpression__FeatureAssignment_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAndExpression__FeatureAssignment_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group__0"
+    // InternalOXtype.g:5537:1: rule__XEqualityExpression__Group__0 : rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 ;
+    public final void rule__XEqualityExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5541:1: ( rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1 )
+            // InternalOXtype.g:5542:2: rule__XEqualityExpression__Group__0__Impl rule__XEqualityExpression__Group__1
+            {
+            pushFollow(FOLLOW_28);
+            rule__XEqualityExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group__0"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group__0__Impl"
+    // InternalOXtype.g:5549:1: rule__XEqualityExpression__Group__0__Impl : ( ruleXRelationalExpression ) ;
+    public final void rule__XEqualityExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5553:1: ( ( ruleXRelationalExpression ) )
+            // InternalOXtype.g:5554:1: ( ruleXRelationalExpression )
+            {
+            // InternalOXtype.g:5554:1: ( ruleXRelationalExpression )
+            // InternalOXtype.g:5555:2: ruleXRelationalExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXRelationalExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group__1"
+    // InternalOXtype.g:5564:1: rule__XEqualityExpression__Group__1 : rule__XEqualityExpression__Group__1__Impl ;
+    public final void rule__XEqualityExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5568:1: ( rule__XEqualityExpression__Group__1__Impl )
+            // InternalOXtype.g:5569:2: rule__XEqualityExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group__1"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group__1__Impl"
+    // InternalOXtype.g:5575:1: rule__XEqualityExpression__Group__1__Impl : ( ( rule__XEqualityExpression__Group_1__0 )* ) ;
+    public final void rule__XEqualityExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5579:1: ( ( ( rule__XEqualityExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:5580:1: ( ( rule__XEqualityExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:5580:1: ( ( rule__XEqualityExpression__Group_1__0 )* )
+            // InternalOXtype.g:5581:2: ( rule__XEqualityExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:5582:2: ( rule__XEqualityExpression__Group_1__0 )*
+            loop60:
+            do {
+                int alt60=2;
+                switch ( input.LA(1) ) {
+                case 21:
+                    {
+                    int LA60_2 = input.LA(2);
+
+                    if ( (synpred104_InternalOXtype()) ) {
+                        alt60=1;
+                    }
+
+
+                    }
+                    break;
+                case 22:
+                    {
+                    int LA60_3 = input.LA(2);
+
+                    if ( (synpred104_InternalOXtype()) ) {
+                        alt60=1;
+                    }
+
+
+                    }
+                    break;
+                case 23:
+                    {
+                    int LA60_4 = input.LA(2);
+
+                    if ( (synpred104_InternalOXtype()) ) {
+                        alt60=1;
+                    }
+
+
+                    }
+                    break;
+                case 24:
+                    {
+                    int LA60_5 = input.LA(2);
+
+                    if ( (synpred104_InternalOXtype()) ) {
+                        alt60=1;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt60) {
+            	case 1 :
+            	    // InternalOXtype.g:5582:3: rule__XEqualityExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_29);
+            	    rule__XEqualityExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop60;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1__0"
+    // InternalOXtype.g:5591:1: rule__XEqualityExpression__Group_1__0 : rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 ;
+    public final void rule__XEqualityExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5595:1: ( rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1 )
+            // InternalOXtype.g:5596:2: rule__XEqualityExpression__Group_1__0__Impl rule__XEqualityExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XEqualityExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1__0__Impl"
+    // InternalOXtype.g:5603:1: rule__XEqualityExpression__Group_1__0__Impl : ( ( rule__XEqualityExpression__Group_1_0__0 ) ) ;
+    public final void rule__XEqualityExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5607:1: ( ( ( rule__XEqualityExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:5608:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:5608:1: ( ( rule__XEqualityExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:5609:2: ( rule__XEqualityExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:5610:2: ( rule__XEqualityExpression__Group_1_0__0 )
+            // InternalOXtype.g:5610:3: rule__XEqualityExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1__1"
+    // InternalOXtype.g:5618:1: rule__XEqualityExpression__Group_1__1 : rule__XEqualityExpression__Group_1__1__Impl ;
+    public final void rule__XEqualityExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5622:1: ( rule__XEqualityExpression__Group_1__1__Impl )
+            // InternalOXtype.g:5623:2: rule__XEqualityExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1__1__Impl"
+    // InternalOXtype.g:5629:1: rule__XEqualityExpression__Group_1__1__Impl : ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) ;
+    public final void rule__XEqualityExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5633:1: ( ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) ) )
+            // InternalOXtype.g:5634:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:5634:1: ( ( rule__XEqualityExpression__RightOperandAssignment_1_1 ) )
+            // InternalOXtype.g:5635:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+            // InternalOXtype.g:5636:2: ( rule__XEqualityExpression__RightOperandAssignment_1_1 )
+            // InternalOXtype.g:5636:3: rule__XEqualityExpression__RightOperandAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__RightOperandAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1_0__0"
+    // InternalOXtype.g:5645:1: rule__XEqualityExpression__Group_1_0__0 : rule__XEqualityExpression__Group_1_0__0__Impl ;
+    public final void rule__XEqualityExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5649:1: ( rule__XEqualityExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:5650:2: rule__XEqualityExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:5656:1: rule__XEqualityExpression__Group_1_0__0__Impl : ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XEqualityExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5660:1: ( ( ( rule__XEqualityExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:5661:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:5661:1: ( ( rule__XEqualityExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:5662:2: ( rule__XEqualityExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:5663:2: ( rule__XEqualityExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:5663:3: rule__XEqualityExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0"
+    // InternalOXtype.g:5672:1: rule__XEqualityExpression__Group_1_0_0__0 : rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 ;
+    public final void rule__XEqualityExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5676:1: ( rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:5677:2: rule__XEqualityExpression__Group_1_0_0__0__Impl rule__XEqualityExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_28);
+            rule__XEqualityExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:5684:1: rule__XEqualityExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XEqualityExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5688:1: ( ( () ) )
+            // InternalOXtype.g:5689:1: ( () )
+            {
+            // InternalOXtype.g:5689:1: ( () )
+            // InternalOXtype.g:5690:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:5691:2: ()
+            // InternalOXtype.g:5691:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1"
+    // InternalOXtype.g:5699:1: rule__XEqualityExpression__Group_1_0_0__1 : rule__XEqualityExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XEqualityExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5703:1: ( rule__XEqualityExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:5704:2: rule__XEqualityExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XEqualityExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:5710:1: rule__XEqualityExpression__Group_1_0_0__1__Impl : ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) ;
+    public final void rule__XEqualityExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5714:1: ( ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) ) )
+            // InternalOXtype.g:5715:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:5715:1: ( ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 ) )
+            // InternalOXtype.g:5716:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+            // InternalOXtype.g:5717:2: ( rule__XEqualityExpression__FeatureAssignment_1_0_0_1 )
+            // InternalOXtype.g:5717:3: rule__XEqualityExpression__FeatureAssignment_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XEqualityExpression__FeatureAssignment_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group__0"
+    // InternalOXtype.g:5726:1: rule__XRelationalExpression__Group__0 : rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 ;
+    public final void rule__XRelationalExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5730:1: ( rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1 )
+            // InternalOXtype.g:5731:2: rule__XRelationalExpression__Group__0__Impl rule__XRelationalExpression__Group__1
+            {
+            pushFollow(FOLLOW_30);
+            rule__XRelationalExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group__0__Impl"
+    // InternalOXtype.g:5738:1: rule__XRelationalExpression__Group__0__Impl : ( ruleXOtherOperatorExpression ) ;
+    public final void rule__XRelationalExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5742:1: ( ( ruleXOtherOperatorExpression ) )
+            // InternalOXtype.g:5743:1: ( ruleXOtherOperatorExpression )
+            {
+            // InternalOXtype.g:5743:1: ( ruleXOtherOperatorExpression )
+            // InternalOXtype.g:5744:2: ruleXOtherOperatorExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXOtherOperatorExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group__1"
+    // InternalOXtype.g:5753:1: rule__XRelationalExpression__Group__1 : rule__XRelationalExpression__Group__1__Impl ;
+    public final void rule__XRelationalExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5757:1: ( rule__XRelationalExpression__Group__1__Impl )
+            // InternalOXtype.g:5758:2: rule__XRelationalExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group__1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group__1__Impl"
+    // InternalOXtype.g:5764:1: rule__XRelationalExpression__Group__1__Impl : ( ( rule__XRelationalExpression__Alternatives_1 )* ) ;
+    public final void rule__XRelationalExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5768:1: ( ( ( rule__XRelationalExpression__Alternatives_1 )* ) )
+            // InternalOXtype.g:5769:1: ( ( rule__XRelationalExpression__Alternatives_1 )* )
+            {
+            // InternalOXtype.g:5769:1: ( ( rule__XRelationalExpression__Alternatives_1 )* )
+            // InternalOXtype.g:5770:2: ( rule__XRelationalExpression__Alternatives_1 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); 
+            }
+            // InternalOXtype.g:5771:2: ( rule__XRelationalExpression__Alternatives_1 )*
+            loop61:
+            do {
+                int alt61=2;
+                switch ( input.LA(1) ) {
+                case 27:
+                    {
+                    int LA61_2 = input.LA(2);
+
+                    if ( (synpred105_InternalOXtype()) ) {
+                        alt61=1;
+                    }
+
+
+                    }
+                    break;
+                case 26:
+                    {
+                    int LA61_3 = input.LA(2);
+
+                    if ( (synpred105_InternalOXtype()) ) {
+                        alt61=1;
+                    }
+
+
+                    }
+                    break;
+                case 59:
+                    {
+                    int LA61_4 = input.LA(2);
+
+                    if ( (synpred105_InternalOXtype()) ) {
+                        alt61=1;
+                    }
+
+
+                    }
+                    break;
+                case 25:
+                    {
+                    int LA61_5 = input.LA(2);
+
+                    if ( (synpred105_InternalOXtype()) ) {
+                        alt61=1;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt61) {
+            	case 1 :
+            	    // InternalOXtype.g:5771:3: rule__XRelationalExpression__Alternatives_1
+            	    {
+            	    pushFollow(FOLLOW_31);
+            	    rule__XRelationalExpression__Alternatives_1();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop61;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getAlternatives_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0__0"
+    // InternalOXtype.g:5780:1: rule__XRelationalExpression__Group_1_0__0 : rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 ;
+    public final void rule__XRelationalExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5784:1: ( rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1 )
+            // InternalOXtype.g:5785:2: rule__XRelationalExpression__Group_1_0__0__Impl rule__XRelationalExpression__Group_1_0__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XRelationalExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:5792:1: rule__XRelationalExpression__Group_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5796:1: ( ( ( rule__XRelationalExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:5797:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:5797:1: ( ( rule__XRelationalExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:5798:2: ( rule__XRelationalExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:5799:2: ( rule__XRelationalExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:5799:3: rule__XRelationalExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0__1"
+    // InternalOXtype.g:5807:1: rule__XRelationalExpression__Group_1_0__1 : rule__XRelationalExpression__Group_1_0__1__Impl ;
+    public final void rule__XRelationalExpression__Group_1_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5811:1: ( rule__XRelationalExpression__Group_1_0__1__Impl )
+            // InternalOXtype.g:5812:2: rule__XRelationalExpression__Group_1_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0__1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0__1__Impl"
+    // InternalOXtype.g:5818:1: rule__XRelationalExpression__Group_1_0__1__Impl : ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5822:1: ( ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) ) )
+            // InternalOXtype.g:5823:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) )
+            {
+            // InternalOXtype.g:5823:1: ( ( rule__XRelationalExpression__TypeAssignment_1_0_1 ) )
+            // InternalOXtype.g:5824:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); 
+            }
+            // InternalOXtype.g:5825:2: ( rule__XRelationalExpression__TypeAssignment_1_0_1 )
+            // InternalOXtype.g:5825:3: rule__XRelationalExpression__TypeAssignment_1_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__TypeAssignment_1_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getTypeAssignment_1_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0__1__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0"
+    // InternalOXtype.g:5834:1: rule__XRelationalExpression__Group_1_0_0__0 : rule__XRelationalExpression__Group_1_0_0__0__Impl ;
+    public final void rule__XRelationalExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5838:1: ( rule__XRelationalExpression__Group_1_0_0__0__Impl )
+            // InternalOXtype.g:5839:2: rule__XRelationalExpression__Group_1_0_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:5845:1: rule__XRelationalExpression__Group_1_0_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5849:1: ( ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) ) )
+            // InternalOXtype.g:5850:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) )
+            {
+            // InternalOXtype.g:5850:1: ( ( rule__XRelationalExpression__Group_1_0_0_0__0 ) )
+            // InternalOXtype.g:5851:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); 
+            }
+            // InternalOXtype.g:5852:2: ( rule__XRelationalExpression__Group_1_0_0_0__0 )
+            // InternalOXtype.g:5852:3: rule__XRelationalExpression__Group_1_0_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0"
+    // InternalOXtype.g:5861:1: rule__XRelationalExpression__Group_1_0_0_0__0 : rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 ;
+    public final void rule__XRelationalExpression__Group_1_0_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5865:1: ( rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1 )
+            // InternalOXtype.g:5866:2: rule__XRelationalExpression__Group_1_0_0_0__0__Impl rule__XRelationalExpression__Group_1_0_0_0__1
+            {
+            pushFollow(FOLLOW_33);
+            rule__XRelationalExpression__Group_1_0_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__0__Impl"
+    // InternalOXtype.g:5873:1: rule__XRelationalExpression__Group_1_0_0_0__0__Impl : ( () ) ;
+    public final void rule__XRelationalExpression__Group_1_0_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5877:1: ( ( () ) )
+            // InternalOXtype.g:5878:1: ( () )
+            {
+            // InternalOXtype.g:5878:1: ( () )
+            // InternalOXtype.g:5879:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); 
+            }
+            // InternalOXtype.g:5880:2: ()
+            // InternalOXtype.g:5880:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1"
+    // InternalOXtype.g:5888:1: rule__XRelationalExpression__Group_1_0_0_0__1 : rule__XRelationalExpression__Group_1_0_0_0__1__Impl ;
+    public final void rule__XRelationalExpression__Group_1_0_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5892:1: ( rule__XRelationalExpression__Group_1_0_0_0__1__Impl )
+            // InternalOXtype.g:5893:2: rule__XRelationalExpression__Group_1_0_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_0_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_0_0_0__1__Impl"
+    // InternalOXtype.g:5899:1: rule__XRelationalExpression__Group_1_0_0_0__1__Impl : ( 'instanceof' ) ;
+    public final void rule__XRelationalExpression__Group_1_0_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5903:1: ( ( 'instanceof' ) )
+            // InternalOXtype.g:5904:1: ( 'instanceof' )
+            {
+            // InternalOXtype.g:5904:1: ( 'instanceof' )
+            // InternalOXtype.g:5905:2: 'instanceof'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); 
+            }
+            match(input,59,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_0_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1__0"
+    // InternalOXtype.g:5915:1: rule__XRelationalExpression__Group_1_1__0 : rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 ;
+    public final void rule__XRelationalExpression__Group_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5919:1: ( rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1 )
+            // InternalOXtype.g:5920:2: rule__XRelationalExpression__Group_1_1__0__Impl rule__XRelationalExpression__Group_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XRelationalExpression__Group_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1__0__Impl"
+    // InternalOXtype.g:5927:1: rule__XRelationalExpression__Group_1_1__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5931:1: ( ( ( rule__XRelationalExpression__Group_1_1_0__0 ) ) )
+            // InternalOXtype.g:5932:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) )
+            {
+            // InternalOXtype.g:5932:1: ( ( rule__XRelationalExpression__Group_1_1_0__0 ) )
+            // InternalOXtype.g:5933:2: ( rule__XRelationalExpression__Group_1_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); 
+            }
+            // InternalOXtype.g:5934:2: ( rule__XRelationalExpression__Group_1_1_0__0 )
+            // InternalOXtype.g:5934:3: rule__XRelationalExpression__Group_1_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1__1"
+    // InternalOXtype.g:5942:1: rule__XRelationalExpression__Group_1_1__1 : rule__XRelationalExpression__Group_1_1__1__Impl ;
+    public final void rule__XRelationalExpression__Group_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5946:1: ( rule__XRelationalExpression__Group_1_1__1__Impl )
+            // InternalOXtype.g:5947:2: rule__XRelationalExpression__Group_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1__1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1__1__Impl"
+    // InternalOXtype.g:5953:1: rule__XRelationalExpression__Group_1_1__1__Impl : ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5957:1: ( ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) ) )
+            // InternalOXtype.g:5958:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) )
+            {
+            // InternalOXtype.g:5958:1: ( ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 ) )
+            // InternalOXtype.g:5959:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); 
+            }
+            // InternalOXtype.g:5960:2: ( rule__XRelationalExpression__RightOperandAssignment_1_1_1 )
+            // InternalOXtype.g:5960:3: rule__XRelationalExpression__RightOperandAssignment_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__RightOperandAssignment_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getRightOperandAssignment_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0"
+    // InternalOXtype.g:5969:1: rule__XRelationalExpression__Group_1_1_0__0 : rule__XRelationalExpression__Group_1_1_0__0__Impl ;
+    public final void rule__XRelationalExpression__Group_1_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5973:1: ( rule__XRelationalExpression__Group_1_1_0__0__Impl )
+            // InternalOXtype.g:5974:2: rule__XRelationalExpression__Group_1_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1_0__0__Impl"
+    // InternalOXtype.g:5980:1: rule__XRelationalExpression__Group_1_1_0__0__Impl : ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:5984:1: ( ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) ) )
+            // InternalOXtype.g:5985:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:5985:1: ( ( rule__XRelationalExpression__Group_1_1_0_0__0 ) )
+            // InternalOXtype.g:5986:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); 
+            }
+            // InternalOXtype.g:5987:2: ( rule__XRelationalExpression__Group_1_1_0_0__0 )
+            // InternalOXtype.g:5987:3: rule__XRelationalExpression__Group_1_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getGroup_1_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0"
+    // InternalOXtype.g:5996:1: rule__XRelationalExpression__Group_1_1_0_0__0 : rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 ;
+    public final void rule__XRelationalExpression__Group_1_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6000:1: ( rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1 )
+            // InternalOXtype.g:6001:2: rule__XRelationalExpression__Group_1_1_0_0__0__Impl rule__XRelationalExpression__Group_1_1_0_0__1
+            {
+            pushFollow(FOLLOW_30);
+            rule__XRelationalExpression__Group_1_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__0__Impl"
+    // InternalOXtype.g:6008:1: rule__XRelationalExpression__Group_1_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XRelationalExpression__Group_1_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6012:1: ( ( () ) )
+            // InternalOXtype.g:6013:1: ( () )
+            {
+            // InternalOXtype.g:6013:1: ( () )
+            // InternalOXtype.g:6014:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); 
+            }
+            // InternalOXtype.g:6015:2: ()
+            // InternalOXtype.g:6015:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1"
+    // InternalOXtype.g:6023:1: rule__XRelationalExpression__Group_1_1_0_0__1 : rule__XRelationalExpression__Group_1_1_0_0__1__Impl ;
+    public final void rule__XRelationalExpression__Group_1_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6027:1: ( rule__XRelationalExpression__Group_1_1_0_0__1__Impl )
+            // InternalOXtype.g:6028:2: rule__XRelationalExpression__Group_1_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__Group_1_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__Group_1_1_0_0__1__Impl"
+    // InternalOXtype.g:6034:1: rule__XRelationalExpression__Group_1_1_0_0__1__Impl : ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) ;
+    public final void rule__XRelationalExpression__Group_1_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6038:1: ( ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) ) )
+            // InternalOXtype.g:6039:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:6039:1: ( ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 ) )
+            // InternalOXtype.g:6040:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); 
+            }
+            // InternalOXtype.g:6041:2: ( rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 )
+            // InternalOXtype.g:6041:3: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getFeatureAssignment_1_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__Group_1_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__OpCompare__Group_1__0"
+    // InternalOXtype.g:6050:1: rule__OpCompare__Group_1__0 : rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 ;
+    public final void rule__OpCompare__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6054:1: ( rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1 )
+            // InternalOXtype.g:6055:2: rule__OpCompare__Group_1__0__Impl rule__OpCompare__Group_1__1
+            {
+            pushFollow(FOLLOW_16);
+            rule__OpCompare__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpCompare__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpCompare__Group_1__0"
+
+
+    // $ANTLR start "rule__OpCompare__Group_1__0__Impl"
+    // InternalOXtype.g:6062:1: rule__OpCompare__Group_1__0__Impl : ( '<' ) ;
+    public final void rule__OpCompare__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6066:1: ( ( '<' ) )
+            // InternalOXtype.g:6067:1: ( '<' )
+            {
+            // InternalOXtype.g:6067:1: ( '<' )
+            // InternalOXtype.g:6068:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpCompare__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__OpCompare__Group_1__1"
+    // InternalOXtype.g:6077:1: rule__OpCompare__Group_1__1 : rule__OpCompare__Group_1__1__Impl ;
+    public final void rule__OpCompare__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6081:1: ( rule__OpCompare__Group_1__1__Impl )
+            // InternalOXtype.g:6082:2: rule__OpCompare__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpCompare__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpCompare__Group_1__1"
+
+
+    // $ANTLR start "rule__OpCompare__Group_1__1__Impl"
+    // InternalOXtype.g:6088:1: rule__OpCompare__Group_1__1__Impl : ( '=' ) ;
+    public final void rule__OpCompare__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6092:1: ( ( '=' ) )
+            // InternalOXtype.g:6093:1: ( '=' )
+            {
+            // InternalOXtype.g:6093:1: ( '=' )
+            // InternalOXtype.g:6094:2: '='
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); 
+            }
+            match(input,13,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpCompare__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group__0"
+    // InternalOXtype.g:6104:1: rule__XOtherOperatorExpression__Group__0 : rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 ;
+    public final void rule__XOtherOperatorExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6108:1: ( rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1 )
+            // InternalOXtype.g:6109:2: rule__XOtherOperatorExpression__Group__0__Impl rule__XOtherOperatorExpression__Group__1
+            {
+            pushFollow(FOLLOW_34);
+            rule__XOtherOperatorExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group__0"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group__0__Impl"
+    // InternalOXtype.g:6116:1: rule__XOtherOperatorExpression__Group__0__Impl : ( ruleXAdditiveExpression ) ;
+    public final void rule__XOtherOperatorExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6120:1: ( ( ruleXAdditiveExpression ) )
+            // InternalOXtype.g:6121:1: ( ruleXAdditiveExpression )
+            {
+            // InternalOXtype.g:6121:1: ( ruleXAdditiveExpression )
+            // InternalOXtype.g:6122:2: ruleXAdditiveExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAdditiveExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group__1"
+    // InternalOXtype.g:6131:1: rule__XOtherOperatorExpression__Group__1 : rule__XOtherOperatorExpression__Group__1__Impl ;
+    public final void rule__XOtherOperatorExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6135:1: ( rule__XOtherOperatorExpression__Group__1__Impl )
+            // InternalOXtype.g:6136:2: rule__XOtherOperatorExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group__1"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group__1__Impl"
+    // InternalOXtype.g:6142:1: rule__XOtherOperatorExpression__Group__1__Impl : ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) ;
+    public final void rule__XOtherOperatorExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6146:1: ( ( ( rule__XOtherOperatorExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:6147:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:6147:1: ( ( rule__XOtherOperatorExpression__Group_1__0 )* )
+            // InternalOXtype.g:6148:2: ( rule__XOtherOperatorExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:6149:2: ( rule__XOtherOperatorExpression__Group_1__0 )*
+            loop62:
+            do {
+                int alt62=2;
+                alt62 = dfa62.predict(input);
+                switch (alt62) {
+            	case 1 :
+            	    // InternalOXtype.g:6149:3: rule__XOtherOperatorExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_35);
+            	    rule__XOtherOperatorExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop62;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0"
+    // InternalOXtype.g:6158:1: rule__XOtherOperatorExpression__Group_1__0 : rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 ;
+    public final void rule__XOtherOperatorExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6162:1: ( rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1 )
+            // InternalOXtype.g:6163:2: rule__XOtherOperatorExpression__Group_1__0__Impl rule__XOtherOperatorExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XOtherOperatorExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1__0__Impl"
+    // InternalOXtype.g:6170:1: rule__XOtherOperatorExpression__Group_1__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) ;
+    public final void rule__XOtherOperatorExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6174:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:6175:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:6175:1: ( ( rule__XOtherOperatorExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:6176:2: ( rule__XOtherOperatorExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:6177:2: ( rule__XOtherOperatorExpression__Group_1_0__0 )
+            // InternalOXtype.g:6177:3: rule__XOtherOperatorExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1"
+    // InternalOXtype.g:6185:1: rule__XOtherOperatorExpression__Group_1__1 : rule__XOtherOperatorExpression__Group_1__1__Impl ;
+    public final void rule__XOtherOperatorExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6189:1: ( rule__XOtherOperatorExpression__Group_1__1__Impl )
+            // InternalOXtype.g:6190:2: rule__XOtherOperatorExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1__1__Impl"
+    // InternalOXtype.g:6196:1: rule__XOtherOperatorExpression__Group_1__1__Impl : ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) ;
+    public final void rule__XOtherOperatorExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6200:1: ( ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) ) )
+            // InternalOXtype.g:6201:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:6201:1: ( ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 ) )
+            // InternalOXtype.g:6202:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+            // InternalOXtype.g:6203:2: ( rule__XOtherOperatorExpression__RightOperandAssignment_1_1 )
+            // InternalOXtype.g:6203:3: rule__XOtherOperatorExpression__RightOperandAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__RightOperandAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0"
+    // InternalOXtype.g:6212:1: rule__XOtherOperatorExpression__Group_1_0__0 : rule__XOtherOperatorExpression__Group_1_0__0__Impl ;
+    public final void rule__XOtherOperatorExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6216:1: ( rule__XOtherOperatorExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:6217:2: rule__XOtherOperatorExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:6223:1: rule__XOtherOperatorExpression__Group_1_0__0__Impl : ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XOtherOperatorExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6227:1: ( ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:6228:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:6228:1: ( ( rule__XOtherOperatorExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:6229:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:6230:2: ( rule__XOtherOperatorExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:6230:3: rule__XOtherOperatorExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0"
+    // InternalOXtype.g:6239:1: rule__XOtherOperatorExpression__Group_1_0_0__0 : rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 ;
+    public final void rule__XOtherOperatorExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6243:1: ( rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:6244:2: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl rule__XOtherOperatorExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_34);
+            rule__XOtherOperatorExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:6251:1: rule__XOtherOperatorExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XOtherOperatorExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6255:1: ( ( () ) )
+            // InternalOXtype.g:6256:1: ( () )
+            {
+            // InternalOXtype.g:6256:1: ( () )
+            // InternalOXtype.g:6257:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:6258:2: ()
+            // InternalOXtype.g:6258:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1"
+    // InternalOXtype.g:6266:1: rule__XOtherOperatorExpression__Group_1_0_0__1 : rule__XOtherOperatorExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XOtherOperatorExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6270:1: ( rule__XOtherOperatorExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:6271:2: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:6277:1: rule__XOtherOperatorExpression__Group_1_0_0__1__Impl : ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) ;
+    public final void rule__XOtherOperatorExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6281:1: ( ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) ) )
+            // InternalOXtype.g:6282:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:6282:1: ( ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 ) )
+            // InternalOXtype.g:6283:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+            // InternalOXtype.g:6284:2: ( rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 )
+            // InternalOXtype.g:6284:3: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_2__0"
+    // InternalOXtype.g:6293:1: rule__OpOther__Group_2__0 : rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 ;
+    public final void rule__OpOther__Group_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6297:1: ( rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1 )
+            // InternalOXtype.g:6298:2: rule__OpOther__Group_2__0__Impl rule__OpOther__Group_2__1
+            {
+            pushFollow(FOLLOW_36);
+            rule__OpOther__Group_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_2__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_2__0__Impl"
+    // InternalOXtype.g:6305:1: rule__OpOther__Group_2__0__Impl : ( '>' ) ;
+    public final void rule__OpOther__Group_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6309:1: ( ( '>' ) )
+            // InternalOXtype.g:6310:1: ( '>' )
+            {
+            // InternalOXtype.g:6310:1: ( '>' )
+            // InternalOXtype.g:6311:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_2__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_2__1"
+    // InternalOXtype.g:6320:1: rule__OpOther__Group_2__1 : rule__OpOther__Group_2__1__Impl ;
+    public final void rule__OpOther__Group_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6324:1: ( rule__OpOther__Group_2__1__Impl )
+            // InternalOXtype.g:6325:2: rule__OpOther__Group_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_2__1"
+
+
+    // $ANTLR start "rule__OpOther__Group_2__1__Impl"
+    // InternalOXtype.g:6331:1: rule__OpOther__Group_2__1__Impl : ( '..' ) ;
+    public final void rule__OpOther__Group_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6335:1: ( ( '..' ) )
+            // InternalOXtype.g:6336:1: ( '..' )
+            {
+            // InternalOXtype.g:6336:1: ( '..' )
+            // InternalOXtype.g:6337:2: '..'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); 
+            }
+            match(input,30,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_2__1__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_5__0"
+    // InternalOXtype.g:6347:1: rule__OpOther__Group_5__0 : rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 ;
+    public final void rule__OpOther__Group_5__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6351:1: ( rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1 )
+            // InternalOXtype.g:6352:2: rule__OpOther__Group_5__0__Impl rule__OpOther__Group_5__1
+            {
+            pushFollow(FOLLOW_37);
+            rule__OpOther__Group_5__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_5__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_5__0__Impl"
+    // InternalOXtype.g:6359:1: rule__OpOther__Group_5__0__Impl : ( '>' ) ;
+    public final void rule__OpOther__Group_5__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6363:1: ( ( '>' ) )
+            // InternalOXtype.g:6364:1: ( '>' )
+            {
+            // InternalOXtype.g:6364:1: ( '>' )
+            // InternalOXtype.g:6365:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_5__1"
+    // InternalOXtype.g:6374:1: rule__OpOther__Group_5__1 : rule__OpOther__Group_5__1__Impl ;
+    public final void rule__OpOther__Group_5__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6378:1: ( rule__OpOther__Group_5__1__Impl )
+            // InternalOXtype.g:6379:2: rule__OpOther__Group_5__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_5__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5__1"
+
+
+    // $ANTLR start "rule__OpOther__Group_5__1__Impl"
+    // InternalOXtype.g:6385:1: rule__OpOther__Group_5__1__Impl : ( ( rule__OpOther__Alternatives_5_1 ) ) ;
+    public final void rule__OpOther__Group_5__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6389:1: ( ( ( rule__OpOther__Alternatives_5_1 ) ) )
+            // InternalOXtype.g:6390:1: ( ( rule__OpOther__Alternatives_5_1 ) )
+            {
+            // InternalOXtype.g:6390:1: ( ( rule__OpOther__Alternatives_5_1 ) )
+            // InternalOXtype.g:6391:2: ( rule__OpOther__Alternatives_5_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); 
+            }
+            // InternalOXtype.g:6392:2: ( rule__OpOther__Alternatives_5_1 )
+            // InternalOXtype.g:6392:3: rule__OpOther__Alternatives_5_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Alternatives_5_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getAlternatives_5_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5__1__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_5_1_0__0"
+    // InternalOXtype.g:6401:1: rule__OpOther__Group_5_1_0__0 : rule__OpOther__Group_5_1_0__0__Impl ;
+    public final void rule__OpOther__Group_5_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6405:1: ( rule__OpOther__Group_5_1_0__0__Impl )
+            // InternalOXtype.g:6406:2: rule__OpOther__Group_5_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_5_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5_1_0__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_5_1_0__0__Impl"
+    // InternalOXtype.g:6412:1: rule__OpOther__Group_5_1_0__0__Impl : ( ( rule__OpOther__Group_5_1_0_0__0 ) ) ;
+    public final void rule__OpOther__Group_5_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6416:1: ( ( ( rule__OpOther__Group_5_1_0_0__0 ) ) )
+            // InternalOXtype.g:6417:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:6417:1: ( ( rule__OpOther__Group_5_1_0_0__0 ) )
+            // InternalOXtype.g:6418:2: ( rule__OpOther__Group_5_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); 
+            }
+            // InternalOXtype.g:6419:2: ( rule__OpOther__Group_5_1_0_0__0 )
+            // InternalOXtype.g:6419:3: rule__OpOther__Group_5_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_5_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getGroup_5_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_5_1_0_0__0"
+    // InternalOXtype.g:6428:1: rule__OpOther__Group_5_1_0_0__0 : rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 ;
+    public final void rule__OpOther__Group_5_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6432:1: ( rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1 )
+            // InternalOXtype.g:6433:2: rule__OpOther__Group_5_1_0_0__0__Impl rule__OpOther__Group_5_1_0_0__1
+            {
+            pushFollow(FOLLOW_37);
+            rule__OpOther__Group_5_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_5_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5_1_0_0__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_5_1_0_0__0__Impl"
+    // InternalOXtype.g:6440:1: rule__OpOther__Group_5_1_0_0__0__Impl : ( '>' ) ;
+    public final void rule__OpOther__Group_5_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6444:1: ( ( '>' ) )
+            // InternalOXtype.g:6445:1: ( '>' )
+            {
+            // InternalOXtype.g:6445:1: ( '>' )
+            // InternalOXtype.g:6446:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_5_1_0_0__1"
+    // InternalOXtype.g:6455:1: rule__OpOther__Group_5_1_0_0__1 : rule__OpOther__Group_5_1_0_0__1__Impl ;
+    public final void rule__OpOther__Group_5_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6459:1: ( rule__OpOther__Group_5_1_0_0__1__Impl )
+            // InternalOXtype.g:6460:2: rule__OpOther__Group_5_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_5_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5_1_0_0__1"
+
+
+    // $ANTLR start "rule__OpOther__Group_5_1_0_0__1__Impl"
+    // InternalOXtype.g:6466:1: rule__OpOther__Group_5_1_0_0__1__Impl : ( '>' ) ;
+    public final void rule__OpOther__Group_5_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6470:1: ( ( '>' ) )
+            // InternalOXtype.g:6471:1: ( '>' )
+            {
+            // InternalOXtype.g:6471:1: ( '>' )
+            // InternalOXtype.g:6472:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_5_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_6__0"
+    // InternalOXtype.g:6482:1: rule__OpOther__Group_6__0 : rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 ;
+    public final void rule__OpOther__Group_6__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6486:1: ( rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1 )
+            // InternalOXtype.g:6487:2: rule__OpOther__Group_6__0__Impl rule__OpOther__Group_6__1
+            {
+            pushFollow(FOLLOW_38);
+            rule__OpOther__Group_6__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_6__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_6__0__Impl"
+    // InternalOXtype.g:6494:1: rule__OpOther__Group_6__0__Impl : ( '<' ) ;
+    public final void rule__OpOther__Group_6__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6498:1: ( ( '<' ) )
+            // InternalOXtype.g:6499:1: ( '<' )
+            {
+            // InternalOXtype.g:6499:1: ( '<' )
+            // InternalOXtype.g:6500:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_6__1"
+    // InternalOXtype.g:6509:1: rule__OpOther__Group_6__1 : rule__OpOther__Group_6__1__Impl ;
+    public final void rule__OpOther__Group_6__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6513:1: ( rule__OpOther__Group_6__1__Impl )
+            // InternalOXtype.g:6514:2: rule__OpOther__Group_6__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_6__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6__1"
+
+
+    // $ANTLR start "rule__OpOther__Group_6__1__Impl"
+    // InternalOXtype.g:6520:1: rule__OpOther__Group_6__1__Impl : ( ( rule__OpOther__Alternatives_6_1 ) ) ;
+    public final void rule__OpOther__Group_6__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6524:1: ( ( ( rule__OpOther__Alternatives_6_1 ) ) )
+            // InternalOXtype.g:6525:1: ( ( rule__OpOther__Alternatives_6_1 ) )
+            {
+            // InternalOXtype.g:6525:1: ( ( rule__OpOther__Alternatives_6_1 ) )
+            // InternalOXtype.g:6526:2: ( rule__OpOther__Alternatives_6_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); 
+            }
+            // InternalOXtype.g:6527:2: ( rule__OpOther__Alternatives_6_1 )
+            // InternalOXtype.g:6527:3: rule__OpOther__Alternatives_6_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Alternatives_6_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getAlternatives_6_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6__1__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_6_1_0__0"
+    // InternalOXtype.g:6536:1: rule__OpOther__Group_6_1_0__0 : rule__OpOther__Group_6_1_0__0__Impl ;
+    public final void rule__OpOther__Group_6_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6540:1: ( rule__OpOther__Group_6_1_0__0__Impl )
+            // InternalOXtype.g:6541:2: rule__OpOther__Group_6_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_6_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6_1_0__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_6_1_0__0__Impl"
+    // InternalOXtype.g:6547:1: rule__OpOther__Group_6_1_0__0__Impl : ( ( rule__OpOther__Group_6_1_0_0__0 ) ) ;
+    public final void rule__OpOther__Group_6_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6551:1: ( ( ( rule__OpOther__Group_6_1_0_0__0 ) ) )
+            // InternalOXtype.g:6552:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:6552:1: ( ( rule__OpOther__Group_6_1_0_0__0 ) )
+            // InternalOXtype.g:6553:2: ( rule__OpOther__Group_6_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); 
+            }
+            // InternalOXtype.g:6554:2: ( rule__OpOther__Group_6_1_0_0__0 )
+            // InternalOXtype.g:6554:3: rule__OpOther__Group_6_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_6_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getGroup_6_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_6_1_0_0__0"
+    // InternalOXtype.g:6563:1: rule__OpOther__Group_6_1_0_0__0 : rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 ;
+    public final void rule__OpOther__Group_6_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6567:1: ( rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1 )
+            // InternalOXtype.g:6568:2: rule__OpOther__Group_6_1_0_0__0__Impl rule__OpOther__Group_6_1_0_0__1
+            {
+            pushFollow(FOLLOW_22);
+            rule__OpOther__Group_6_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_6_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6_1_0_0__0"
+
+
+    // $ANTLR start "rule__OpOther__Group_6_1_0_0__0__Impl"
+    // InternalOXtype.g:6575:1: rule__OpOther__Group_6_1_0_0__0__Impl : ( '<' ) ;
+    public final void rule__OpOther__Group_6_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6579:1: ( ( '<' ) )
+            // InternalOXtype.g:6580:1: ( '<' )
+            {
+            // InternalOXtype.g:6580:1: ( '<' )
+            // InternalOXtype.g:6581:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__OpOther__Group_6_1_0_0__1"
+    // InternalOXtype.g:6590:1: rule__OpOther__Group_6_1_0_0__1 : rule__OpOther__Group_6_1_0_0__1__Impl ;
+    public final void rule__OpOther__Group_6_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6594:1: ( rule__OpOther__Group_6_1_0_0__1__Impl )
+            // InternalOXtype.g:6595:2: rule__OpOther__Group_6_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__OpOther__Group_6_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6_1_0_0__1"
+
+
+    // $ANTLR start "rule__OpOther__Group_6_1_0_0__1__Impl"
+    // InternalOXtype.g:6601:1: rule__OpOther__Group_6_1_0_0__1__Impl : ( '<' ) ;
+    public final void rule__OpOther__Group_6_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6605:1: ( ( '<' ) )
+            // InternalOXtype.g:6606:1: ( '<' )
+            {
+            // InternalOXtype.g:6606:1: ( '<' )
+            // InternalOXtype.g:6607:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__OpOther__Group_6_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group__0"
+    // InternalOXtype.g:6617:1: rule__XAdditiveExpression__Group__0 : rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 ;
+    public final void rule__XAdditiveExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6621:1: ( rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1 )
+            // InternalOXtype.g:6622:2: rule__XAdditiveExpression__Group__0__Impl rule__XAdditiveExpression__Group__1
+            {
+            pushFollow(FOLLOW_39);
+            rule__XAdditiveExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group__0"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group__0__Impl"
+    // InternalOXtype.g:6629:1: rule__XAdditiveExpression__Group__0__Impl : ( ruleXMultiplicativeExpression ) ;
+    public final void rule__XAdditiveExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6633:1: ( ( ruleXMultiplicativeExpression ) )
+            // InternalOXtype.g:6634:1: ( ruleXMultiplicativeExpression )
+            {
+            // InternalOXtype.g:6634:1: ( ruleXMultiplicativeExpression )
+            // InternalOXtype.g:6635:2: ruleXMultiplicativeExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXMultiplicativeExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group__1"
+    // InternalOXtype.g:6644:1: rule__XAdditiveExpression__Group__1 : rule__XAdditiveExpression__Group__1__Impl ;
+    public final void rule__XAdditiveExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6648:1: ( rule__XAdditiveExpression__Group__1__Impl )
+            // InternalOXtype.g:6649:2: rule__XAdditiveExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group__1"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group__1__Impl"
+    // InternalOXtype.g:6655:1: rule__XAdditiveExpression__Group__1__Impl : ( ( rule__XAdditiveExpression__Group_1__0 )* ) ;
+    public final void rule__XAdditiveExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6659:1: ( ( ( rule__XAdditiveExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:6660:1: ( ( rule__XAdditiveExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:6660:1: ( ( rule__XAdditiveExpression__Group_1__0 )* )
+            // InternalOXtype.g:6661:2: ( rule__XAdditiveExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:6662:2: ( rule__XAdditiveExpression__Group_1__0 )*
+            loop63:
+            do {
+                int alt63=2;
+                int LA63_0 = input.LA(1);
+
+                if ( (LA63_0==35) ) {
+                    int LA63_2 = input.LA(2);
+
+                    if ( (synpred107_InternalOXtype()) ) {
+                        alt63=1;
+                    }
+
+
+                }
+                else if ( (LA63_0==34) ) {
+                    int LA63_3 = input.LA(2);
+
+                    if ( (synpred107_InternalOXtype()) ) {
+                        alt63=1;
+                    }
+
+
+                }
+
+
+                switch (alt63) {
+            	case 1 :
+            	    // InternalOXtype.g:6662:3: rule__XAdditiveExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_40);
+            	    rule__XAdditiveExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop63;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1__0"
+    // InternalOXtype.g:6671:1: rule__XAdditiveExpression__Group_1__0 : rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 ;
+    public final void rule__XAdditiveExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6675:1: ( rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1 )
+            // InternalOXtype.g:6676:2: rule__XAdditiveExpression__Group_1__0__Impl rule__XAdditiveExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XAdditiveExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1__0__Impl"
+    // InternalOXtype.g:6683:1: rule__XAdditiveExpression__Group_1__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) ;
+    public final void rule__XAdditiveExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6687:1: ( ( ( rule__XAdditiveExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:6688:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:6688:1: ( ( rule__XAdditiveExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:6689:2: ( rule__XAdditiveExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:6690:2: ( rule__XAdditiveExpression__Group_1_0__0 )
+            // InternalOXtype.g:6690:3: rule__XAdditiveExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1__1"
+    // InternalOXtype.g:6698:1: rule__XAdditiveExpression__Group_1__1 : rule__XAdditiveExpression__Group_1__1__Impl ;
+    public final void rule__XAdditiveExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6702:1: ( rule__XAdditiveExpression__Group_1__1__Impl )
+            // InternalOXtype.g:6703:2: rule__XAdditiveExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1__1__Impl"
+    // InternalOXtype.g:6709:1: rule__XAdditiveExpression__Group_1__1__Impl : ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) ;
+    public final void rule__XAdditiveExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6713:1: ( ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) ) )
+            // InternalOXtype.g:6714:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:6714:1: ( ( rule__XAdditiveExpression__RightOperandAssignment_1_1 ) )
+            // InternalOXtype.g:6715:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+            // InternalOXtype.g:6716:2: ( rule__XAdditiveExpression__RightOperandAssignment_1_1 )
+            // InternalOXtype.g:6716:3: rule__XAdditiveExpression__RightOperandAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__RightOperandAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0"
+    // InternalOXtype.g:6725:1: rule__XAdditiveExpression__Group_1_0__0 : rule__XAdditiveExpression__Group_1_0__0__Impl ;
+    public final void rule__XAdditiveExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6729:1: ( rule__XAdditiveExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:6730:2: rule__XAdditiveExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:6736:1: rule__XAdditiveExpression__Group_1_0__0__Impl : ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XAdditiveExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6740:1: ( ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:6741:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:6741:1: ( ( rule__XAdditiveExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:6742:2: ( rule__XAdditiveExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:6743:2: ( rule__XAdditiveExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:6743:3: rule__XAdditiveExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0"
+    // InternalOXtype.g:6752:1: rule__XAdditiveExpression__Group_1_0_0__0 : rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 ;
+    public final void rule__XAdditiveExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6756:1: ( rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:6757:2: rule__XAdditiveExpression__Group_1_0_0__0__Impl rule__XAdditiveExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_39);
+            rule__XAdditiveExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:6764:1: rule__XAdditiveExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XAdditiveExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6768:1: ( ( () ) )
+            // InternalOXtype.g:6769:1: ( () )
+            {
+            // InternalOXtype.g:6769:1: ( () )
+            // InternalOXtype.g:6770:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:6771:2: ()
+            // InternalOXtype.g:6771:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1"
+    // InternalOXtype.g:6779:1: rule__XAdditiveExpression__Group_1_0_0__1 : rule__XAdditiveExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XAdditiveExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6783:1: ( rule__XAdditiveExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:6784:2: rule__XAdditiveExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:6790:1: rule__XAdditiveExpression__Group_1_0_0__1__Impl : ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) ;
+    public final void rule__XAdditiveExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6794:1: ( ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) ) )
+            // InternalOXtype.g:6795:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:6795:1: ( ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 ) )
+            // InternalOXtype.g:6796:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+            // InternalOXtype.g:6797:2: ( rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 )
+            // InternalOXtype.g:6797:3: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XAdditiveExpression__FeatureAssignment_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group__0"
+    // InternalOXtype.g:6806:1: rule__XMultiplicativeExpression__Group__0 : rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 ;
+    public final void rule__XMultiplicativeExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6810:1: ( rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1 )
+            // InternalOXtype.g:6811:2: rule__XMultiplicativeExpression__Group__0__Impl rule__XMultiplicativeExpression__Group__1
+            {
+            pushFollow(FOLLOW_41);
+            rule__XMultiplicativeExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group__0"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group__0__Impl"
+    // InternalOXtype.g:6818:1: rule__XMultiplicativeExpression__Group__0__Impl : ( ruleXUnaryOperation ) ;
+    public final void rule__XMultiplicativeExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6822:1: ( ( ruleXUnaryOperation ) )
+            // InternalOXtype.g:6823:1: ( ruleXUnaryOperation )
+            {
+            // InternalOXtype.g:6823:1: ( ruleXUnaryOperation )
+            // InternalOXtype.g:6824:2: ruleXUnaryOperation
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXUnaryOperation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group__1"
+    // InternalOXtype.g:6833:1: rule__XMultiplicativeExpression__Group__1 : rule__XMultiplicativeExpression__Group__1__Impl ;
+    public final void rule__XMultiplicativeExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6837:1: ( rule__XMultiplicativeExpression__Group__1__Impl )
+            // InternalOXtype.g:6838:2: rule__XMultiplicativeExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group__1"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group__1__Impl"
+    // InternalOXtype.g:6844:1: rule__XMultiplicativeExpression__Group__1__Impl : ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) ;
+    public final void rule__XMultiplicativeExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6848:1: ( ( ( rule__XMultiplicativeExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:6849:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:6849:1: ( ( rule__XMultiplicativeExpression__Group_1__0 )* )
+            // InternalOXtype.g:6850:2: ( rule__XMultiplicativeExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:6851:2: ( rule__XMultiplicativeExpression__Group_1__0 )*
+            loop64:
+            do {
+                int alt64=2;
+                switch ( input.LA(1) ) {
+                case 36:
+                    {
+                    int LA64_2 = input.LA(2);
+
+                    if ( (synpred108_InternalOXtype()) ) {
+                        alt64=1;
+                    }
+
+
+                    }
+                    break;
+                case 37:
+                    {
+                    int LA64_3 = input.LA(2);
+
+                    if ( (synpred108_InternalOXtype()) ) {
+                        alt64=1;
+                    }
+
+
+                    }
+                    break;
+                case 38:
+                    {
+                    int LA64_4 = input.LA(2);
+
+                    if ( (synpred108_InternalOXtype()) ) {
+                        alt64=1;
+                    }
+
+
+                    }
+                    break;
+                case 39:
+                    {
+                    int LA64_5 = input.LA(2);
+
+                    if ( (synpred108_InternalOXtype()) ) {
+                        alt64=1;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt64) {
+            	case 1 :
+            	    // InternalOXtype.g:6851:3: rule__XMultiplicativeExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_42);
+            	    rule__XMultiplicativeExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop64;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0"
+    // InternalOXtype.g:6860:1: rule__XMultiplicativeExpression__Group_1__0 : rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 ;
+    public final void rule__XMultiplicativeExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6864:1: ( rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1 )
+            // InternalOXtype.g:6865:2: rule__XMultiplicativeExpression__Group_1__0__Impl rule__XMultiplicativeExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XMultiplicativeExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1__0__Impl"
+    // InternalOXtype.g:6872:1: rule__XMultiplicativeExpression__Group_1__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) ;
+    public final void rule__XMultiplicativeExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6876:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:6877:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:6877:1: ( ( rule__XMultiplicativeExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:6878:2: ( rule__XMultiplicativeExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:6879:2: ( rule__XMultiplicativeExpression__Group_1_0__0 )
+            // InternalOXtype.g:6879:3: rule__XMultiplicativeExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1"
+    // InternalOXtype.g:6887:1: rule__XMultiplicativeExpression__Group_1__1 : rule__XMultiplicativeExpression__Group_1__1__Impl ;
+    public final void rule__XMultiplicativeExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6891:1: ( rule__XMultiplicativeExpression__Group_1__1__Impl )
+            // InternalOXtype.g:6892:2: rule__XMultiplicativeExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1__1__Impl"
+    // InternalOXtype.g:6898:1: rule__XMultiplicativeExpression__Group_1__1__Impl : ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) ;
+    public final void rule__XMultiplicativeExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6902:1: ( ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) ) )
+            // InternalOXtype.g:6903:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:6903:1: ( ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 ) )
+            // InternalOXtype.g:6904:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+            // InternalOXtype.g:6905:2: ( rule__XMultiplicativeExpression__RightOperandAssignment_1_1 )
+            // InternalOXtype.g:6905:3: rule__XMultiplicativeExpression__RightOperandAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__RightOperandAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0"
+    // InternalOXtype.g:6914:1: rule__XMultiplicativeExpression__Group_1_0__0 : rule__XMultiplicativeExpression__Group_1_0__0__Impl ;
+    public final void rule__XMultiplicativeExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6918:1: ( rule__XMultiplicativeExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:6919:2: rule__XMultiplicativeExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:6925:1: rule__XMultiplicativeExpression__Group_1_0__0__Impl : ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XMultiplicativeExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6929:1: ( ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:6930:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:6930:1: ( ( rule__XMultiplicativeExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:6931:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:6932:2: ( rule__XMultiplicativeExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:6932:3: rule__XMultiplicativeExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0"
+    // InternalOXtype.g:6941:1: rule__XMultiplicativeExpression__Group_1_0_0__0 : rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 ;
+    public final void rule__XMultiplicativeExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6945:1: ( rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:6946:2: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl rule__XMultiplicativeExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_41);
+            rule__XMultiplicativeExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:6953:1: rule__XMultiplicativeExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XMultiplicativeExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6957:1: ( ( () ) )
+            // InternalOXtype.g:6958:1: ( () )
+            {
+            // InternalOXtype.g:6958:1: ( () )
+            // InternalOXtype.g:6959:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:6960:2: ()
+            // InternalOXtype.g:6960:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1"
+    // InternalOXtype.g:6968:1: rule__XMultiplicativeExpression__Group_1_0_0__1 : rule__XMultiplicativeExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XMultiplicativeExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6972:1: ( rule__XMultiplicativeExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:6973:2: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:6979:1: rule__XMultiplicativeExpression__Group_1_0_0__1__Impl : ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) ;
+    public final void rule__XMultiplicativeExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6983:1: ( ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) ) )
+            // InternalOXtype.g:6984:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:6984:1: ( ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 ) )
+            // InternalOXtype.g:6985:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+            // InternalOXtype.g:6986:2: ( rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 )
+            // InternalOXtype.g:6986:3: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureAssignment_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Group_0__0"
+    // InternalOXtype.g:6995:1: rule__XUnaryOperation__Group_0__0 : rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 ;
+    public final void rule__XUnaryOperation__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:6999:1: ( rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1 )
+            // InternalOXtype.g:7000:2: rule__XUnaryOperation__Group_0__0__Impl rule__XUnaryOperation__Group_0__1
+            {
+            pushFollow(FOLLOW_43);
+            rule__XUnaryOperation__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XUnaryOperation__Group_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Group_0__0"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Group_0__0__Impl"
+    // InternalOXtype.g:7007:1: rule__XUnaryOperation__Group_0__0__Impl : ( () ) ;
+    public final void rule__XUnaryOperation__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7011:1: ( ( () ) )
+            // InternalOXtype.g:7012:1: ( () )
+            {
+            // InternalOXtype.g:7012:1: ( () )
+            // InternalOXtype.g:7013:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); 
+            }
+            // InternalOXtype.g:7014:2: ()
+            // InternalOXtype.g:7014:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Group_0__1"
+    // InternalOXtype.g:7022:1: rule__XUnaryOperation__Group_0__1 : rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 ;
+    public final void rule__XUnaryOperation__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7026:1: ( rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2 )
+            // InternalOXtype.g:7027:2: rule__XUnaryOperation__Group_0__1__Impl rule__XUnaryOperation__Group_0__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__XUnaryOperation__Group_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XUnaryOperation__Group_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Group_0__1"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Group_0__1__Impl"
+    // InternalOXtype.g:7034:1: rule__XUnaryOperation__Group_0__1__Impl : ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) ;
+    public final void rule__XUnaryOperation__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7038:1: ( ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) ) )
+            // InternalOXtype.g:7039:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) )
+            {
+            // InternalOXtype.g:7039:1: ( ( rule__XUnaryOperation__FeatureAssignment_0_1 ) )
+            // InternalOXtype.g:7040:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); 
+            }
+            // InternalOXtype.g:7041:2: ( rule__XUnaryOperation__FeatureAssignment_0_1 )
+            // InternalOXtype.g:7041:3: rule__XUnaryOperation__FeatureAssignment_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XUnaryOperation__FeatureAssignment_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getFeatureAssignment_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Group_0__1__Impl"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Group_0__2"
+    // InternalOXtype.g:7049:1: rule__XUnaryOperation__Group_0__2 : rule__XUnaryOperation__Group_0__2__Impl ;
+    public final void rule__XUnaryOperation__Group_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7053:1: ( rule__XUnaryOperation__Group_0__2__Impl )
+            // InternalOXtype.g:7054:2: rule__XUnaryOperation__Group_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XUnaryOperation__Group_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Group_0__2"
+
+
+    // $ANTLR start "rule__XUnaryOperation__Group_0__2__Impl"
+    // InternalOXtype.g:7060:1: rule__XUnaryOperation__Group_0__2__Impl : ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) ;
+    public final void rule__XUnaryOperation__Group_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7064:1: ( ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) ) )
+            // InternalOXtype.g:7065:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) )
+            {
+            // InternalOXtype.g:7065:1: ( ( rule__XUnaryOperation__OperandAssignment_0_2 ) )
+            // InternalOXtype.g:7066:2: ( rule__XUnaryOperation__OperandAssignment_0_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); 
+            }
+            // InternalOXtype.g:7067:2: ( rule__XUnaryOperation__OperandAssignment_0_2 )
+            // InternalOXtype.g:7067:3: rule__XUnaryOperation__OperandAssignment_0_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XUnaryOperation__OperandAssignment_0_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getOperandAssignment_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__Group_0__2__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group__0"
+    // InternalOXtype.g:7076:1: rule__XCastedExpression__Group__0 : rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 ;
+    public final void rule__XCastedExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7080:1: ( rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1 )
+            // InternalOXtype.g:7081:2: rule__XCastedExpression__Group__0__Impl rule__XCastedExpression__Group__1
+            {
+            pushFollow(FOLLOW_44);
+            rule__XCastedExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group__0"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group__0__Impl"
+    // InternalOXtype.g:7088:1: rule__XCastedExpression__Group__0__Impl : ( ruleXPostfixOperation ) ;
+    public final void rule__XCastedExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7092:1: ( ( ruleXPostfixOperation ) )
+            // InternalOXtype.g:7093:1: ( ruleXPostfixOperation )
+            {
+            // InternalOXtype.g:7093:1: ( ruleXPostfixOperation )
+            // InternalOXtype.g:7094:2: ruleXPostfixOperation
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXPostfixOperation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group__1"
+    // InternalOXtype.g:7103:1: rule__XCastedExpression__Group__1 : rule__XCastedExpression__Group__1__Impl ;
+    public final void rule__XCastedExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7107:1: ( rule__XCastedExpression__Group__1__Impl )
+            // InternalOXtype.g:7108:2: rule__XCastedExpression__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group__1"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group__1__Impl"
+    // InternalOXtype.g:7114:1: rule__XCastedExpression__Group__1__Impl : ( ( rule__XCastedExpression__Group_1__0 )* ) ;
+    public final void rule__XCastedExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7118:1: ( ( ( rule__XCastedExpression__Group_1__0 )* ) )
+            // InternalOXtype.g:7119:1: ( ( rule__XCastedExpression__Group_1__0 )* )
+            {
+            // InternalOXtype.g:7119:1: ( ( rule__XCastedExpression__Group_1__0 )* )
+            // InternalOXtype.g:7120:2: ( rule__XCastedExpression__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:7121:2: ( rule__XCastedExpression__Group_1__0 )*
+            loop65:
+            do {
+                int alt65=2;
+                int LA65_0 = input.LA(1);
+
+                if ( (LA65_0==60) ) {
+                    int LA65_2 = input.LA(2);
+
+                    if ( (synpred109_InternalOXtype()) ) {
+                        alt65=1;
+                    }
+
+
+                }
+
+
+                switch (alt65) {
+            	case 1 :
+            	    // InternalOXtype.g:7121:3: rule__XCastedExpression__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_45);
+            	    rule__XCastedExpression__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop65;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1__0"
+    // InternalOXtype.g:7130:1: rule__XCastedExpression__Group_1__0 : rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 ;
+    public final void rule__XCastedExpression__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7134:1: ( rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1 )
+            // InternalOXtype.g:7135:2: rule__XCastedExpression__Group_1__0__Impl rule__XCastedExpression__Group_1__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XCastedExpression__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1__0"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1__0__Impl"
+    // InternalOXtype.g:7142:1: rule__XCastedExpression__Group_1__0__Impl : ( ( rule__XCastedExpression__Group_1_0__0 ) ) ;
+    public final void rule__XCastedExpression__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7146:1: ( ( ( rule__XCastedExpression__Group_1_0__0 ) ) )
+            // InternalOXtype.g:7147:1: ( ( rule__XCastedExpression__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:7147:1: ( ( rule__XCastedExpression__Group_1_0__0 ) )
+            // InternalOXtype.g:7148:2: ( rule__XCastedExpression__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:7149:2: ( rule__XCastedExpression__Group_1_0__0 )
+            // InternalOXtype.g:7149:3: rule__XCastedExpression__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1__1"
+    // InternalOXtype.g:7157:1: rule__XCastedExpression__Group_1__1 : rule__XCastedExpression__Group_1__1__Impl ;
+    public final void rule__XCastedExpression__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7161:1: ( rule__XCastedExpression__Group_1__1__Impl )
+            // InternalOXtype.g:7162:2: rule__XCastedExpression__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1__1"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1__1__Impl"
+    // InternalOXtype.g:7168:1: rule__XCastedExpression__Group_1__1__Impl : ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) ;
+    public final void rule__XCastedExpression__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7172:1: ( ( ( rule__XCastedExpression__TypeAssignment_1_1 ) ) )
+            // InternalOXtype.g:7173:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:7173:1: ( ( rule__XCastedExpression__TypeAssignment_1_1 ) )
+            // InternalOXtype.g:7174:2: ( rule__XCastedExpression__TypeAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); 
+            }
+            // InternalOXtype.g:7175:2: ( rule__XCastedExpression__TypeAssignment_1_1 )
+            // InternalOXtype.g:7175:3: rule__XCastedExpression__TypeAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__TypeAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getTypeAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1_0__0"
+    // InternalOXtype.g:7184:1: rule__XCastedExpression__Group_1_0__0 : rule__XCastedExpression__Group_1_0__0__Impl ;
+    public final void rule__XCastedExpression__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7188:1: ( rule__XCastedExpression__Group_1_0__0__Impl )
+            // InternalOXtype.g:7189:2: rule__XCastedExpression__Group_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1_0__0__Impl"
+    // InternalOXtype.g:7195:1: rule__XCastedExpression__Group_1_0__0__Impl : ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) ;
+    public final void rule__XCastedExpression__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7199:1: ( ( ( rule__XCastedExpression__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:7200:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:7200:1: ( ( rule__XCastedExpression__Group_1_0_0__0 ) )
+            // InternalOXtype.g:7201:2: ( rule__XCastedExpression__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:7202:2: ( rule__XCastedExpression__Group_1_0_0__0 )
+            // InternalOXtype.g:7202:3: rule__XCastedExpression__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0"
+    // InternalOXtype.g:7211:1: rule__XCastedExpression__Group_1_0_0__0 : rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 ;
+    public final void rule__XCastedExpression__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7215:1: ( rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1 )
+            // InternalOXtype.g:7216:2: rule__XCastedExpression__Group_1_0_0__0__Impl rule__XCastedExpression__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_44);
+            rule__XCastedExpression__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:7223:1: rule__XCastedExpression__Group_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XCastedExpression__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7227:1: ( ( () ) )
+            // InternalOXtype.g:7228:1: ( () )
+            {
+            // InternalOXtype.g:7228:1: ( () )
+            // InternalOXtype.g:7229:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); 
+            }
+            // InternalOXtype.g:7230:2: ()
+            // InternalOXtype.g:7230:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1"
+    // InternalOXtype.g:7238:1: rule__XCastedExpression__Group_1_0_0__1 : rule__XCastedExpression__Group_1_0_0__1__Impl ;
+    public final void rule__XCastedExpression__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7242:1: ( rule__XCastedExpression__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:7243:2: rule__XCastedExpression__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCastedExpression__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XCastedExpression__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:7249:1: rule__XCastedExpression__Group_1_0_0__1__Impl : ( 'as' ) ;
+    public final void rule__XCastedExpression__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7253:1: ( ( 'as' ) )
+            // InternalOXtype.g:7254:1: ( 'as' )
+            {
+            // InternalOXtype.g:7254:1: ( 'as' )
+            // InternalOXtype.g:7255:2: 'as'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); 
+            }
+            match(input,60,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group__0"
+    // InternalOXtype.g:7265:1: rule__XPostfixOperation__Group__0 : rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 ;
+    public final void rule__XPostfixOperation__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7269:1: ( rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1 )
+            // InternalOXtype.g:7270:2: rule__XPostfixOperation__Group__0__Impl rule__XPostfixOperation__Group__1
+            {
+            pushFollow(FOLLOW_46);
+            rule__XPostfixOperation__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group__0"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group__0__Impl"
+    // InternalOXtype.g:7277:1: rule__XPostfixOperation__Group__0__Impl : ( ruleXMemberFeatureCall ) ;
+    public final void rule__XPostfixOperation__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7281:1: ( ( ruleXMemberFeatureCall ) )
+            // InternalOXtype.g:7282:1: ( ruleXMemberFeatureCall )
+            {
+            // InternalOXtype.g:7282:1: ( ruleXMemberFeatureCall )
+            // InternalOXtype.g:7283:2: ruleXMemberFeatureCall
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXMemberFeatureCall();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group__1"
+    // InternalOXtype.g:7292:1: rule__XPostfixOperation__Group__1 : rule__XPostfixOperation__Group__1__Impl ;
+    public final void rule__XPostfixOperation__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7296:1: ( rule__XPostfixOperation__Group__1__Impl )
+            // InternalOXtype.g:7297:2: rule__XPostfixOperation__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group__1"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group__1__Impl"
+    // InternalOXtype.g:7303:1: rule__XPostfixOperation__Group__1__Impl : ( ( rule__XPostfixOperation__Group_1__0 )? ) ;
+    public final void rule__XPostfixOperation__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7307:1: ( ( ( rule__XPostfixOperation__Group_1__0 )? ) )
+            // InternalOXtype.g:7308:1: ( ( rule__XPostfixOperation__Group_1__0 )? )
+            {
+            // InternalOXtype.g:7308:1: ( ( rule__XPostfixOperation__Group_1__0 )? )
+            // InternalOXtype.g:7309:2: ( rule__XPostfixOperation__Group_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:7310:2: ( rule__XPostfixOperation__Group_1__0 )?
+            int alt66=2;
+            int LA66_0 = input.LA(1);
+
+            if ( (LA66_0==41) ) {
+                int LA66_1 = input.LA(2);
+
+                if ( (synpred110_InternalOXtype()) ) {
+                    alt66=1;
+                }
+            }
+            else if ( (LA66_0==42) ) {
+                int LA66_2 = input.LA(2);
+
+                if ( (synpred110_InternalOXtype()) ) {
+                    alt66=1;
+                }
+            }
+            switch (alt66) {
+                case 1 :
+                    // InternalOXtype.g:7310:3: rule__XPostfixOperation__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XPostfixOperation__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group_1__0"
+    // InternalOXtype.g:7319:1: rule__XPostfixOperation__Group_1__0 : rule__XPostfixOperation__Group_1__0__Impl ;
+    public final void rule__XPostfixOperation__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7323:1: ( rule__XPostfixOperation__Group_1__0__Impl )
+            // InternalOXtype.g:7324:2: rule__XPostfixOperation__Group_1__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group_1__0"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group_1__0__Impl"
+    // InternalOXtype.g:7330:1: rule__XPostfixOperation__Group_1__0__Impl : ( ( rule__XPostfixOperation__Group_1_0__0 ) ) ;
+    public final void rule__XPostfixOperation__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7334:1: ( ( ( rule__XPostfixOperation__Group_1_0__0 ) ) )
+            // InternalOXtype.g:7335:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:7335:1: ( ( rule__XPostfixOperation__Group_1_0__0 ) )
+            // InternalOXtype.g:7336:2: ( rule__XPostfixOperation__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:7337:2: ( rule__XPostfixOperation__Group_1_0__0 )
+            // InternalOXtype.g:7337:3: rule__XPostfixOperation__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group_1_0__0"
+    // InternalOXtype.g:7346:1: rule__XPostfixOperation__Group_1_0__0 : rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 ;
+    public final void rule__XPostfixOperation__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7350:1: ( rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1 )
+            // InternalOXtype.g:7351:2: rule__XPostfixOperation__Group_1_0__0__Impl rule__XPostfixOperation__Group_1_0__1
+            {
+            pushFollow(FOLLOW_46);
+            rule__XPostfixOperation__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group_1_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group_1_0__0__Impl"
+    // InternalOXtype.g:7358:1: rule__XPostfixOperation__Group_1_0__0__Impl : ( () ) ;
+    public final void rule__XPostfixOperation__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7362:1: ( ( () ) )
+            // InternalOXtype.g:7363:1: ( () )
+            {
+            // InternalOXtype.g:7363:1: ( () )
+            // InternalOXtype.g:7364:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); 
+            }
+            // InternalOXtype.g:7365:2: ()
+            // InternalOXtype.g:7365:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group_1_0__1"
+    // InternalOXtype.g:7373:1: rule__XPostfixOperation__Group_1_0__1 : rule__XPostfixOperation__Group_1_0__1__Impl ;
+    public final void rule__XPostfixOperation__Group_1_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7377:1: ( rule__XPostfixOperation__Group_1_0__1__Impl )
+            // InternalOXtype.g:7378:2: rule__XPostfixOperation__Group_1_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__Group_1_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group_1_0__1"
+
+
+    // $ANTLR start "rule__XPostfixOperation__Group_1_0__1__Impl"
+    // InternalOXtype.g:7384:1: rule__XPostfixOperation__Group_1_0__1__Impl : ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) ;
+    public final void rule__XPostfixOperation__Group_1_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7388:1: ( ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) ) )
+            // InternalOXtype.g:7389:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) )
+            {
+            // InternalOXtype.g:7389:1: ( ( rule__XPostfixOperation__FeatureAssignment_1_0_1 ) )
+            // InternalOXtype.g:7390:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); 
+            }
+            // InternalOXtype.g:7391:2: ( rule__XPostfixOperation__FeatureAssignment_1_0_1 )
+            // InternalOXtype.g:7391:3: rule__XPostfixOperation__FeatureAssignment_1_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XPostfixOperation__FeatureAssignment_1_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getFeatureAssignment_1_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__Group_1_0__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group__0"
+    // InternalOXtype.g:7400:1: rule__XMemberFeatureCall__Group__0 : rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 ;
+    public final void rule__XMemberFeatureCall__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7404:1: ( rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1 )
+            // InternalOXtype.g:7405:2: rule__XMemberFeatureCall__Group__0__Impl rule__XMemberFeatureCall__Group__1
+            {
+            pushFollow(FOLLOW_47);
+            rule__XMemberFeatureCall__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group__0__Impl"
+    // InternalOXtype.g:7412:1: rule__XMemberFeatureCall__Group__0__Impl : ( ruleXPrimaryExpression ) ;
+    public final void rule__XMemberFeatureCall__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7416:1: ( ( ruleXPrimaryExpression ) )
+            // InternalOXtype.g:7417:1: ( ruleXPrimaryExpression )
+            {
+            // InternalOXtype.g:7417:1: ( ruleXPrimaryExpression )
+            // InternalOXtype.g:7418:2: ruleXPrimaryExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXPrimaryExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group__1"
+    // InternalOXtype.g:7427:1: rule__XMemberFeatureCall__Group__1 : rule__XMemberFeatureCall__Group__1__Impl ;
+    public final void rule__XMemberFeatureCall__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7431:1: ( rule__XMemberFeatureCall__Group__1__Impl )
+            // InternalOXtype.g:7432:2: rule__XMemberFeatureCall__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group__1__Impl"
+    // InternalOXtype.g:7438:1: rule__XMemberFeatureCall__Group__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) ;
+    public final void rule__XMemberFeatureCall__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7442:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1 )* ) )
+            // InternalOXtype.g:7443:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* )
+            {
+            // InternalOXtype.g:7443:1: ( ( rule__XMemberFeatureCall__Alternatives_1 )* )
+            // InternalOXtype.g:7444:2: ( rule__XMemberFeatureCall__Alternatives_1 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); 
+            }
+            // InternalOXtype.g:7445:2: ( rule__XMemberFeatureCall__Alternatives_1 )*
+            loop67:
+            do {
+                int alt67=2;
+                switch ( input.LA(1) ) {
+                case 43:
+                    {
+                    int LA67_2 = input.LA(2);
+
+                    if ( (synpred111_InternalOXtype()) ) {
+                        alt67=1;
+                    }
+
+
+                    }
+                    break;
+                case 84:
+                    {
+                    int LA67_3 = input.LA(2);
+
+                    if ( (synpred111_InternalOXtype()) ) {
+                        alt67=1;
+                    }
+
+
+                    }
+                    break;
+                case 85:
+                    {
+                    int LA67_4 = input.LA(2);
+
+                    if ( (synpred111_InternalOXtype()) ) {
+                        alt67=1;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt67) {
+            	case 1 :
+            	    // InternalOXtype.g:7445:3: rule__XMemberFeatureCall__Alternatives_1
+            	    {
+            	    pushFollow(FOLLOW_48);
+            	    rule__XMemberFeatureCall__Alternatives_1();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop67;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0"
+    // InternalOXtype.g:7454:1: rule__XMemberFeatureCall__Group_1_0__0 : rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7458:1: ( rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1 )
+            // InternalOXtype.g:7459:2: rule__XMemberFeatureCall__Group_1_0__0__Impl rule__XMemberFeatureCall__Group_1_0__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XMemberFeatureCall__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__0__Impl"
+    // InternalOXtype.g:7466:1: rule__XMemberFeatureCall__Group_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7470:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) ) )
+            // InternalOXtype.g:7471:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:7471:1: ( ( rule__XMemberFeatureCall__Group_1_0_0__0 ) )
+            // InternalOXtype.g:7472:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:7473:2: ( rule__XMemberFeatureCall__Group_1_0_0__0 )
+            // InternalOXtype.g:7473:3: rule__XMemberFeatureCall__Group_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1"
+    // InternalOXtype.g:7481:1: rule__XMemberFeatureCall__Group_1_0__1 : rule__XMemberFeatureCall__Group_1_0__1__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7485:1: ( rule__XMemberFeatureCall__Group_1_0__1__Impl )
+            // InternalOXtype.g:7486:2: rule__XMemberFeatureCall__Group_1_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0__1__Impl"
+    // InternalOXtype.g:7492:1: rule__XMemberFeatureCall__Group_1_0__1__Impl : ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7496:1: ( ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) ) )
+            // InternalOXtype.g:7497:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) )
+            {
+            // InternalOXtype.g:7497:1: ( ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 ) )
+            // InternalOXtype.g:7498:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); 
+            }
+            // InternalOXtype.g:7499:2: ( rule__XMemberFeatureCall__ValueAssignment_1_0_1 )
+            // InternalOXtype.g:7499:3: rule__XMemberFeatureCall__ValueAssignment_1_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__ValueAssignment_1_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getValueAssignment_1_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0"
+    // InternalOXtype.g:7508:1: rule__XMemberFeatureCall__Group_1_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0__0__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7512:1: ( rule__XMemberFeatureCall__Group_1_0_0__0__Impl )
+            // InternalOXtype.g:7513:2: rule__XMemberFeatureCall__Group_1_0_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:7519:1: rule__XMemberFeatureCall__Group_1_0_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7523:1: ( ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) ) )
+            // InternalOXtype.g:7524:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) )
+            {
+            // InternalOXtype.g:7524:1: ( ( rule__XMemberFeatureCall__Group_1_0_0_0__0 ) )
+            // InternalOXtype.g:7525:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); 
+            }
+            // InternalOXtype.g:7526:2: ( rule__XMemberFeatureCall__Group_1_0_0_0__0 )
+            // InternalOXtype.g:7526:3: rule__XMemberFeatureCall__Group_1_0_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0"
+    // InternalOXtype.g:7535:1: rule__XMemberFeatureCall__Group_1_0_0_0__0 : rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7539:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1 )
+            // InternalOXtype.g:7540:2: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl rule__XMemberFeatureCall__Group_1_0_0_0__1
+            {
+            pushFollow(FOLLOW_49);
+            rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl"
+    // InternalOXtype.g:7547:1: rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl : ( () ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7551:1: ( ( () ) )
+            // InternalOXtype.g:7552:1: ( () )
+            {
+            // InternalOXtype.g:7552:1: ( () )
+            // InternalOXtype.g:7553:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); 
+            }
+            // InternalOXtype.g:7554:2: ()
+            // InternalOXtype.g:7554:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1"
+    // InternalOXtype.g:7562:1: rule__XMemberFeatureCall__Group_1_0_0_0__1 : rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7566:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2 )
+            // InternalOXtype.g:7567:2: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl rule__XMemberFeatureCall__Group_1_0_0_0__2
+            {
+            pushFollow(FOLLOW_20);
+            rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl"
+    // InternalOXtype.g:7574:1: rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7578:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) ) )
+            // InternalOXtype.g:7579:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) )
+            {
+            // InternalOXtype.g:7579:1: ( ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 ) )
+            // InternalOXtype.g:7580:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); 
+            }
+            // InternalOXtype.g:7581:2: ( rule__XMemberFeatureCall__Alternatives_1_0_0_0_1 )
+            // InternalOXtype.g:7581:3: rule__XMemberFeatureCall__Alternatives_1_0_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Alternatives_1_0_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_0_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2"
+    // InternalOXtype.g:7589:1: rule__XMemberFeatureCall__Group_1_0_0_0__2 : rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7593:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3 )
+            // InternalOXtype.g:7594:2: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl rule__XMemberFeatureCall__Group_1_0_0_0__3
+            {
+            pushFollow(FOLLOW_16);
+            rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0_0__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl"
+    // InternalOXtype.g:7601:1: rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7605:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) ) )
+            // InternalOXtype.g:7606:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) )
+            {
+            // InternalOXtype.g:7606:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 ) )
+            // InternalOXtype.g:7607:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); 
+            }
+            // InternalOXtype.g:7608:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 )
+            // InternalOXtype.g:7608:3: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_0_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3"
+    // InternalOXtype.g:7616:1: rule__XMemberFeatureCall__Group_1_0_0_0__3 : rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7620:1: ( rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl )
+            // InternalOXtype.g:7621:2: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl"
+    // InternalOXtype.g:7627:1: rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl : ( ruleOpSingleAssign ) ;
+    public final void rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7631:1: ( ( ruleOpSingleAssign ) )
+            // InternalOXtype.g:7632:1: ( ruleOpSingleAssign )
+            {
+            // InternalOXtype.g:7632:1: ( ruleOpSingleAssign )
+            // InternalOXtype.g:7633:2: ruleOpSingleAssign
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpSingleAssign();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_0_0_0__3__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0"
+    // InternalOXtype.g:7643:1: rule__XMemberFeatureCall__Group_1_1__0 : rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7647:1: ( rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1 )
+            // InternalOXtype.g:7648:2: rule__XMemberFeatureCall__Group_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1__1
+            {
+            pushFollow(FOLLOW_50);
+            rule__XMemberFeatureCall__Group_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__0__Impl"
+    // InternalOXtype.g:7655:1: rule__XMemberFeatureCall__Group_1_1__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7659:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) ) )
+            // InternalOXtype.g:7660:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) )
+            {
+            // InternalOXtype.g:7660:1: ( ( rule__XMemberFeatureCall__Group_1_1_0__0 ) )
+            // InternalOXtype.g:7661:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); 
+            }
+            // InternalOXtype.g:7662:2: ( rule__XMemberFeatureCall__Group_1_1_0__0 )
+            // InternalOXtype.g:7662:3: rule__XMemberFeatureCall__Group_1_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1"
+    // InternalOXtype.g:7670:1: rule__XMemberFeatureCall__Group_1_1__1 : rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 ;
+    public final void rule__XMemberFeatureCall__Group_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7674:1: ( rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2 )
+            // InternalOXtype.g:7675:2: rule__XMemberFeatureCall__Group_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1__2
+            {
+            pushFollow(FOLLOW_50);
+            rule__XMemberFeatureCall__Group_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__1__Impl"
+    // InternalOXtype.g:7682:1: rule__XMemberFeatureCall__Group_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7686:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? ) )
+            // InternalOXtype.g:7687:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? )
+            {
+            // InternalOXtype.g:7687:1: ( ( rule__XMemberFeatureCall__Group_1_1_1__0 )? )
+            // InternalOXtype.g:7688:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); 
+            }
+            // InternalOXtype.g:7689:2: ( rule__XMemberFeatureCall__Group_1_1_1__0 )?
+            int alt68=2;
+            int LA68_0 = input.LA(1);
+
+            if ( (LA68_0==27) ) {
+                alt68=1;
+            }
+            switch (alt68) {
+                case 1 :
+                    // InternalOXtype.g:7689:3: rule__XMemberFeatureCall__Group_1_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__Group_1_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2"
+    // InternalOXtype.g:7697:1: rule__XMemberFeatureCall__Group_1_1__2 : rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 ;
+    public final void rule__XMemberFeatureCall__Group_1_1__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7701:1: ( rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3 )
+            // InternalOXtype.g:7702:2: rule__XMemberFeatureCall__Group_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1__3
+            {
+            pushFollow(FOLLOW_51);
+            rule__XMemberFeatureCall__Group_1_1__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__2__Impl"
+    // InternalOXtype.g:7709:1: rule__XMemberFeatureCall__Group_1_1__2__Impl : ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7713:1: ( ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) ) )
+            // InternalOXtype.g:7714:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) )
+            {
+            // InternalOXtype.g:7714:1: ( ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 ) )
+            // InternalOXtype.g:7715:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); 
+            }
+            // InternalOXtype.g:7716:2: ( rule__XMemberFeatureCall__FeatureAssignment_1_1_2 )
+            // InternalOXtype.g:7716:3: rule__XMemberFeatureCall__FeatureAssignment_1_1_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__FeatureAssignment_1_1_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getFeatureAssignment_1_1_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__2__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3"
+    // InternalOXtype.g:7724:1: rule__XMemberFeatureCall__Group_1_1__3 : rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 ;
+    public final void rule__XMemberFeatureCall__Group_1_1__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7728:1: ( rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4 )
+            // InternalOXtype.g:7729:2: rule__XMemberFeatureCall__Group_1_1__3__Impl rule__XMemberFeatureCall__Group_1_1__4
+            {
+            pushFollow(FOLLOW_51);
+            rule__XMemberFeatureCall__Group_1_1__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__3__Impl"
+    // InternalOXtype.g:7736:1: rule__XMemberFeatureCall__Group_1_1__3__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7740:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? ) )
+            // InternalOXtype.g:7741:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? )
+            {
+            // InternalOXtype.g:7741:1: ( ( rule__XMemberFeatureCall__Group_1_1_3__0 )? )
+            // InternalOXtype.g:7742:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); 
+            }
+            // InternalOXtype.g:7743:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?
+            int alt69=2;
+            alt69 = dfa69.predict(input);
+            switch (alt69) {
+                case 1 :
+                    // InternalOXtype.g:7743:3: rule__XMemberFeatureCall__Group_1_1_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__Group_1_1_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__3__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4"
+    // InternalOXtype.g:7751:1: rule__XMemberFeatureCall__Group_1_1__4 : rule__XMemberFeatureCall__Group_1_1__4__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7755:1: ( rule__XMemberFeatureCall__Group_1_1__4__Impl )
+            // InternalOXtype.g:7756:2: rule__XMemberFeatureCall__Group_1_1__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1__4__Impl"
+    // InternalOXtype.g:7762:1: rule__XMemberFeatureCall__Group_1_1__4__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7766:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? ) )
+            // InternalOXtype.g:7767:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? )
+            {
+            // InternalOXtype.g:7767:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )? )
+            // InternalOXtype.g:7768:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); 
+            }
+            // InternalOXtype.g:7769:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?
+            int alt70=2;
+            alt70 = dfa70.predict(input);
+            switch (alt70) {
+                case 1 :
+                    // InternalOXtype.g:7769:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1__4__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0"
+    // InternalOXtype.g:7778:1: rule__XMemberFeatureCall__Group_1_1_0__0 : rule__XMemberFeatureCall__Group_1_1_0__0__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7782:1: ( rule__XMemberFeatureCall__Group_1_1_0__0__Impl )
+            // InternalOXtype.g:7783:2: rule__XMemberFeatureCall__Group_1_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0__0__Impl"
+    // InternalOXtype.g:7789:1: rule__XMemberFeatureCall__Group_1_1_0__0__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7793:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) ) )
+            // InternalOXtype.g:7794:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:7794:1: ( ( rule__XMemberFeatureCall__Group_1_1_0_0__0 ) )
+            // InternalOXtype.g:7795:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); 
+            }
+            // InternalOXtype.g:7796:2: ( rule__XMemberFeatureCall__Group_1_1_0_0__0 )
+            // InternalOXtype.g:7796:3: rule__XMemberFeatureCall__Group_1_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0"
+    // InternalOXtype.g:7805:1: rule__XMemberFeatureCall__Group_1_1_0_0__0 : rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7809:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1 )
+            // InternalOXtype.g:7810:2: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl rule__XMemberFeatureCall__Group_1_1_0_0__1
+            {
+            pushFollow(FOLLOW_47);
+            rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl"
+    // InternalOXtype.g:7817:1: rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl : ( () ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7821:1: ( ( () ) )
+            // InternalOXtype.g:7822:1: ( () )
+            {
+            // InternalOXtype.g:7822:1: ( () )
+            // InternalOXtype.g:7823:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); 
+            }
+            // InternalOXtype.g:7824:2: ()
+            // InternalOXtype.g:7824:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1"
+    // InternalOXtype.g:7832:1: rule__XMemberFeatureCall__Group_1_1_0_0__1 : rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7836:1: ( rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl )
+            // InternalOXtype.g:7837:2: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl"
+    // InternalOXtype.g:7843:1: rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7847:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) ) )
+            // InternalOXtype.g:7848:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) )
+            {
+            // InternalOXtype.g:7848:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 ) )
+            // InternalOXtype.g:7849:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); 
+            }
+            // InternalOXtype.g:7850:2: ( rule__XMemberFeatureCall__Alternatives_1_1_0_0_1 )
+            // InternalOXtype.g:7850:3: rule__XMemberFeatureCall__Alternatives_1_1_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Alternatives_1_1_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0"
+    // InternalOXtype.g:7859:1: rule__XMemberFeatureCall__Group_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7863:1: ( rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1 )
+            // InternalOXtype.g:7864:2: rule__XMemberFeatureCall__Group_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_1__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__XMemberFeatureCall__Group_1_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__0__Impl"
+    // InternalOXtype.g:7871:1: rule__XMemberFeatureCall__Group_1_1_1__0__Impl : ( '<' ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7875:1: ( ( '<' ) )
+            // InternalOXtype.g:7876:1: ( '<' )
+            {
+            // InternalOXtype.g:7876:1: ( '<' )
+            // InternalOXtype.g:7877:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1"
+    // InternalOXtype.g:7886:1: rule__XMemberFeatureCall__Group_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7890:1: ( rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2 )
+            // InternalOXtype.g:7891:2: rule__XMemberFeatureCall__Group_1_1_1__1__Impl rule__XMemberFeatureCall__Group_1_1_1__2
+            {
+            pushFollow(FOLLOW_53);
+            rule__XMemberFeatureCall__Group_1_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_1__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__1__Impl"
+    // InternalOXtype.g:7898:1: rule__XMemberFeatureCall__Group_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7902:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) ) )
+            // InternalOXtype.g:7903:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) )
+            {
+            // InternalOXtype.g:7903:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 ) )
+            // InternalOXtype.g:7904:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); 
+            }
+            // InternalOXtype.g:7905:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 )
+            // InternalOXtype.g:7905:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2"
+    // InternalOXtype.g:7913:1: rule__XMemberFeatureCall__Group_1_1_1__2 : rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7917:1: ( rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3 )
+            // InternalOXtype.g:7918:2: rule__XMemberFeatureCall__Group_1_1_1__2__Impl rule__XMemberFeatureCall__Group_1_1_1__3
+            {
+            pushFollow(FOLLOW_53);
+            rule__XMemberFeatureCall__Group_1_1_1__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_1__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__2__Impl"
+    // InternalOXtype.g:7925:1: rule__XMemberFeatureCall__Group_1_1_1__2__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7929:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* ) )
+            // InternalOXtype.g:7930:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* )
+            {
+            // InternalOXtype.g:7930:1: ( ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )* )
+            // InternalOXtype.g:7931:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); 
+            }
+            // InternalOXtype.g:7932:2: ( rule__XMemberFeatureCall__Group_1_1_1_2__0 )*
+            loop71:
+            do {
+                int alt71=2;
+                int LA71_0 = input.LA(1);
+
+                if ( (LA71_0==55) ) {
+                    alt71=1;
+                }
+
+
+                switch (alt71) {
+            	case 1 :
+            	    // InternalOXtype.g:7932:3: rule__XMemberFeatureCall__Group_1_1_1_2__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XMemberFeatureCall__Group_1_1_1_2__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop71;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_1_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__2__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3"
+    // InternalOXtype.g:7940:1: rule__XMemberFeatureCall__Group_1_1_1__3 : rule__XMemberFeatureCall__Group_1_1_1__3__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7944:1: ( rule__XMemberFeatureCall__Group_1_1_1__3__Impl )
+            // InternalOXtype.g:7945:2: rule__XMemberFeatureCall__Group_1_1_1__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_1__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1__3__Impl"
+    // InternalOXtype.g:7951:1: rule__XMemberFeatureCall__Group_1_1_1__3__Impl : ( '>' ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7955:1: ( ( '>' ) )
+            // InternalOXtype.g:7956:1: ( '>' )
+            {
+            // InternalOXtype.g:7956:1: ( '>' )
+            // InternalOXtype.g:7957:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1__3__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0"
+    // InternalOXtype.g:7967:1: rule__XMemberFeatureCall__Group_1_1_1_2__0 : rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7971:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1 )
+            // InternalOXtype.g:7972:2: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl rule__XMemberFeatureCall__Group_1_1_1_2__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_1_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl"
+    // InternalOXtype.g:7979:1: rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl : ( ',' ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7983:1: ( ( ',' ) )
+            // InternalOXtype.g:7984:1: ( ',' )
+            {
+            // InternalOXtype.g:7984:1: ( ',' )
+            // InternalOXtype.g:7985:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1"
+    // InternalOXtype.g:7994:1: rule__XMemberFeatureCall__Group_1_1_1_2__1 : rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:7998:1: ( rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl )
+            // InternalOXtype.g:7999:2: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl"
+    // InternalOXtype.g:8005:1: rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl : ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8009:1: ( ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) ) )
+            // InternalOXtype.g:8010:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) )
+            {
+            // InternalOXtype.g:8010:1: ( ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 ) )
+            // InternalOXtype.g:8011:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); 
+            }
+            // InternalOXtype.g:8012:2: ( rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 )
+            // InternalOXtype.g:8012:3: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsAssignment_1_1_1_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_1_2__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0"
+    // InternalOXtype.g:8021:1: rule__XMemberFeatureCall__Group_1_1_3__0 : rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8025:1: ( rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1 )
+            // InternalOXtype.g:8026:2: rule__XMemberFeatureCall__Group_1_1_3__0__Impl rule__XMemberFeatureCall__Group_1_1_3__1
+            {
+            pushFollow(FOLLOW_54);
+            rule__XMemberFeatureCall__Group_1_1_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__0__Impl"
+    // InternalOXtype.g:8033:1: rule__XMemberFeatureCall__Group_1_1_3__0__Impl : ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8037:1: ( ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) ) )
+            // InternalOXtype.g:8038:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) )
+            {
+            // InternalOXtype.g:8038:1: ( ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 ) )
+            // InternalOXtype.g:8039:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); 
+            }
+            // InternalOXtype.g:8040:2: ( rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 )
+            // InternalOXtype.g:8040:3: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallAssignment_1_1_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1"
+    // InternalOXtype.g:8048:1: rule__XMemberFeatureCall__Group_1_1_3__1 : rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8052:1: ( rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2 )
+            // InternalOXtype.g:8053:2: rule__XMemberFeatureCall__Group_1_1_3__1__Impl rule__XMemberFeatureCall__Group_1_1_3__2
+            {
+            pushFollow(FOLLOW_54);
+            rule__XMemberFeatureCall__Group_1_1_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__1__Impl"
+    // InternalOXtype.g:8060:1: rule__XMemberFeatureCall__Group_1_1_3__1__Impl : ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8064:1: ( ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? ) )
+            // InternalOXtype.g:8065:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? )
+            {
+            // InternalOXtype.g:8065:1: ( ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )? )
+            // InternalOXtype.g:8066:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); 
+            }
+            // InternalOXtype.g:8067:2: ( rule__XMemberFeatureCall__Alternatives_1_1_3_1 )?
+            int alt72=2;
+            int LA72_0 = input.LA(1);
+
+            if ( ((LA72_0>=RULE_ID && LA72_0<=RULE_STRING)||LA72_0==27||LA72_0==31||(LA72_0>=34 && LA72_0<=35)||LA72_0==40||(LA72_0>=45 && LA72_0<=50)||LA72_0==53||(LA72_0>=57 && LA72_0<=58)||LA72_0==61||LA72_0==63||LA72_0==65||(LA72_0>=69 && LA72_0<=77)||LA72_0==79||LA72_0==86||LA72_0==88) ) {
+                alt72=1;
+            }
+            switch (alt72) {
+                case 1 :
+                    // InternalOXtype.g:8067:3: rule__XMemberFeatureCall__Alternatives_1_1_3_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XMemberFeatureCall__Alternatives_1_1_3_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getAlternatives_1_1_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2"
+    // InternalOXtype.g:8075:1: rule__XMemberFeatureCall__Group_1_1_3__2 : rule__XMemberFeatureCall__Group_1_1_3__2__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8079:1: ( rule__XMemberFeatureCall__Group_1_1_3__2__Impl )
+            // InternalOXtype.g:8080:2: rule__XMemberFeatureCall__Group_1_1_3__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3__2__Impl"
+    // InternalOXtype.g:8086:1: rule__XMemberFeatureCall__Group_1_1_3__2__Impl : ( ')' ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8090:1: ( ( ')' ) )
+            // InternalOXtype.g:8091:1: ( ')' )
+            {
+            // InternalOXtype.g:8091:1: ( ')' )
+            // InternalOXtype.g:8092:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3__2__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"
+    // InternalOXtype.g:8102:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8106:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1 )
+            // InternalOXtype.g:8107:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl"
+    // InternalOXtype.g:8114:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8118:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) ) )
+            // InternalOXtype.g:8119:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) )
+            {
+            // InternalOXtype.g:8119:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 ) )
+            // InternalOXtype.g:8120:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); 
+            }
+            // InternalOXtype.g:8121:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 )
+            // InternalOXtype.g:8121:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1"
+    // InternalOXtype.g:8129:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8133:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl )
+            // InternalOXtype.g:8134:2: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl"
+    // InternalOXtype.g:8140:1: rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl : ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8144:1: ( ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* ) )
+            // InternalOXtype.g:8145:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* )
+            {
+            // InternalOXtype.g:8145:1: ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )* )
+            // InternalOXtype.g:8146:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); 
+            }
+            // InternalOXtype.g:8147:2: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 )*
+            loop73:
+            do {
+                int alt73=2;
+                int LA73_0 = input.LA(1);
+
+                if ( (LA73_0==55) ) {
+                    alt73=1;
+                }
+
+
+                switch (alt73) {
+            	case 1 :
+            	    // InternalOXtype.g:8147:3: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop73;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getGroup_1_1_3_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"
+    // InternalOXtype.g:8156:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8160:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 )
+            // InternalOXtype.g:8161:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl"
+    // InternalOXtype.g:8168:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8172:1: ( ( ',' ) )
+            // InternalOXtype.g:8173:1: ( ',' )
+            {
+            // InternalOXtype.g:8173:1: ( ',' )
+            // InternalOXtype.g:8174:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1"
+    // InternalOXtype.g:8183:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1 : rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8187:1: ( rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl )
+            // InternalOXtype.g:8188:2: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl"
+    // InternalOXtype.g:8194:1: rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl : ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) ;
+    public final void rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8198:1: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) ) )
+            // InternalOXtype.g:8199:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) )
+            {
+            // InternalOXtype.g:8199:1: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 ) )
+            // InternalOXtype.g:8200:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); 
+            }
+            // InternalOXtype.g:8201:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 )
+            // InternalOXtype.g:8201:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__Group_1_1_3_1_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__0"
+    // InternalOXtype.g:8210:1: rule__XSetLiteral__Group__0 : rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 ;
+    public final void rule__XSetLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8214:1: ( rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1 )
+            // InternalOXtype.g:8215:2: rule__XSetLiteral__Group__0__Impl rule__XSetLiteral__Group__1
+            {
+            pushFollow(FOLLOW_18);
+            rule__XSetLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__0__Impl"
+    // InternalOXtype.g:8222:1: rule__XSetLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XSetLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8226:1: ( ( () ) )
+            // InternalOXtype.g:8227:1: ( () )
+            {
+            // InternalOXtype.g:8227:1: ( () )
+            // InternalOXtype.g:8228:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); 
+            }
+            // InternalOXtype.g:8229:2: ()
+            // InternalOXtype.g:8229:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__1"
+    // InternalOXtype.g:8237:1: rule__XSetLiteral__Group__1 : rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 ;
+    public final void rule__XSetLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8241:1: ( rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2 )
+            // InternalOXtype.g:8242:2: rule__XSetLiteral__Group__1__Impl rule__XSetLiteral__Group__2
+            {
+            pushFollow(FOLLOW_55);
+            rule__XSetLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__1__Impl"
+    // InternalOXtype.g:8249:1: rule__XSetLiteral__Group__1__Impl : ( '#' ) ;
+    public final void rule__XSetLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8253:1: ( ( '#' ) )
+            // InternalOXtype.g:8254:1: ( '#' )
+            {
+            // InternalOXtype.g:8254:1: ( '#' )
+            // InternalOXtype.g:8255:2: '#'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); 
+            }
+            match(input,57,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__2"
+    // InternalOXtype.g:8264:1: rule__XSetLiteral__Group__2 : rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 ;
+    public final void rule__XSetLiteral__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8268:1: ( rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3 )
+            // InternalOXtype.g:8269:2: rule__XSetLiteral__Group__2__Impl rule__XSetLiteral__Group__3
+            {
+            pushFollow(FOLLOW_56);
+            rule__XSetLiteral__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__2"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__2__Impl"
+    // InternalOXtype.g:8276:1: rule__XSetLiteral__Group__2__Impl : ( '{' ) ;
+    public final void rule__XSetLiteral__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8280:1: ( ( '{' ) )
+            // InternalOXtype.g:8281:1: ( '{' )
+            {
+            // InternalOXtype.g:8281:1: ( '{' )
+            // InternalOXtype.g:8282:2: '{'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); 
+            }
+            match(input,61,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__3"
+    // InternalOXtype.g:8291:1: rule__XSetLiteral__Group__3 : rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 ;
+    public final void rule__XSetLiteral__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8295:1: ( rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4 )
+            // InternalOXtype.g:8296:2: rule__XSetLiteral__Group__3__Impl rule__XSetLiteral__Group__4
+            {
+            pushFollow(FOLLOW_56);
+            rule__XSetLiteral__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__3"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__3__Impl"
+    // InternalOXtype.g:8303:1: rule__XSetLiteral__Group__3__Impl : ( ( rule__XSetLiteral__Group_3__0 )? ) ;
+    public final void rule__XSetLiteral__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8307:1: ( ( ( rule__XSetLiteral__Group_3__0 )? ) )
+            // InternalOXtype.g:8308:1: ( ( rule__XSetLiteral__Group_3__0 )? )
+            {
+            // InternalOXtype.g:8308:1: ( ( rule__XSetLiteral__Group_3__0 )? )
+            // InternalOXtype.g:8309:2: ( rule__XSetLiteral__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:8310:2: ( rule__XSetLiteral__Group_3__0 )?
+            int alt74=2;
+            int LA74_0 = input.LA(1);
+
+            if ( ((LA74_0>=RULE_ID && LA74_0<=RULE_STRING)||LA74_0==27||(LA74_0>=34 && LA74_0<=35)||LA74_0==40||(LA74_0>=45 && LA74_0<=50)||LA74_0==53||(LA74_0>=57 && LA74_0<=58)||LA74_0==61||LA74_0==63||LA74_0==65||(LA74_0>=69 && LA74_0<=77)||LA74_0==79||LA74_0==88) ) {
+                alt74=1;
+            }
+            switch (alt74) {
+                case 1 :
+                    // InternalOXtype.g:8310:3: rule__XSetLiteral__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XSetLiteral__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__4"
+    // InternalOXtype.g:8318:1: rule__XSetLiteral__Group__4 : rule__XSetLiteral__Group__4__Impl ;
+    public final void rule__XSetLiteral__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8322:1: ( rule__XSetLiteral__Group__4__Impl )
+            // InternalOXtype.g:8323:2: rule__XSetLiteral__Group__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__4"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group__4__Impl"
+    // InternalOXtype.g:8329:1: rule__XSetLiteral__Group__4__Impl : ( '}' ) ;
+    public final void rule__XSetLiteral__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8333:1: ( ( '}' ) )
+            // InternalOXtype.g:8334:1: ( '}' )
+            {
+            // InternalOXtype.g:8334:1: ( '}' )
+            // InternalOXtype.g:8335:2: '}'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); 
+            }
+            match(input,62,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3__0"
+    // InternalOXtype.g:8345:1: rule__XSetLiteral__Group_3__0 : rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 ;
+    public final void rule__XSetLiteral__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8349:1: ( rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1 )
+            // InternalOXtype.g:8350:2: rule__XSetLiteral__Group_3__0__Impl rule__XSetLiteral__Group_3__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XSetLiteral__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3__0"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3__0__Impl"
+    // InternalOXtype.g:8357:1: rule__XSetLiteral__Group_3__0__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) ;
+    public final void rule__XSetLiteral__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8361:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) ) )
+            // InternalOXtype.g:8362:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) )
+            {
+            // InternalOXtype.g:8362:1: ( ( rule__XSetLiteral__ElementsAssignment_3_0 ) )
+            // InternalOXtype.g:8363:2: ( rule__XSetLiteral__ElementsAssignment_3_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); 
+            }
+            // InternalOXtype.g:8364:2: ( rule__XSetLiteral__ElementsAssignment_3_0 )
+            // InternalOXtype.g:8364:3: rule__XSetLiteral__ElementsAssignment_3_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__ElementsAssignment_3_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3__1"
+    // InternalOXtype.g:8372:1: rule__XSetLiteral__Group_3__1 : rule__XSetLiteral__Group_3__1__Impl ;
+    public final void rule__XSetLiteral__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8376:1: ( rule__XSetLiteral__Group_3__1__Impl )
+            // InternalOXtype.g:8377:2: rule__XSetLiteral__Group_3__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3__1"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3__1__Impl"
+    // InternalOXtype.g:8383:1: rule__XSetLiteral__Group_3__1__Impl : ( ( rule__XSetLiteral__Group_3_1__0 )* ) ;
+    public final void rule__XSetLiteral__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8387:1: ( ( ( rule__XSetLiteral__Group_3_1__0 )* ) )
+            // InternalOXtype.g:8388:1: ( ( rule__XSetLiteral__Group_3_1__0 )* )
+            {
+            // InternalOXtype.g:8388:1: ( ( rule__XSetLiteral__Group_3_1__0 )* )
+            // InternalOXtype.g:8389:2: ( rule__XSetLiteral__Group_3_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); 
+            }
+            // InternalOXtype.g:8390:2: ( rule__XSetLiteral__Group_3_1__0 )*
+            loop75:
+            do {
+                int alt75=2;
+                int LA75_0 = input.LA(1);
+
+                if ( (LA75_0==55) ) {
+                    alt75=1;
+                }
+
+
+                switch (alt75) {
+            	case 1 :
+            	    // InternalOXtype.g:8390:3: rule__XSetLiteral__Group_3_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XSetLiteral__Group_3_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop75;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getGroup_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3_1__0"
+    // InternalOXtype.g:8399:1: rule__XSetLiteral__Group_3_1__0 : rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 ;
+    public final void rule__XSetLiteral__Group_3_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8403:1: ( rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1 )
+            // InternalOXtype.g:8404:2: rule__XSetLiteral__Group_3_1__0__Impl rule__XSetLiteral__Group_3_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XSetLiteral__Group_3_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group_3_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3_1__0"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3_1__0__Impl"
+    // InternalOXtype.g:8411:1: rule__XSetLiteral__Group_3_1__0__Impl : ( ',' ) ;
+    public final void rule__XSetLiteral__Group_3_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8415:1: ( ( ',' ) )
+            // InternalOXtype.g:8416:1: ( ',' )
+            {
+            // InternalOXtype.g:8416:1: ( ',' )
+            // InternalOXtype.g:8417:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3_1__0__Impl"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3_1__1"
+    // InternalOXtype.g:8426:1: rule__XSetLiteral__Group_3_1__1 : rule__XSetLiteral__Group_3_1__1__Impl ;
+    public final void rule__XSetLiteral__Group_3_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8430:1: ( rule__XSetLiteral__Group_3_1__1__Impl )
+            // InternalOXtype.g:8431:2: rule__XSetLiteral__Group_3_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__Group_3_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3_1__1"
+
+
+    // $ANTLR start "rule__XSetLiteral__Group_3_1__1__Impl"
+    // InternalOXtype.g:8437:1: rule__XSetLiteral__Group_3_1__1__Impl : ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) ;
+    public final void rule__XSetLiteral__Group_3_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8441:1: ( ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) ) )
+            // InternalOXtype.g:8442:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) )
+            {
+            // InternalOXtype.g:8442:1: ( ( rule__XSetLiteral__ElementsAssignment_3_1_1 ) )
+            // InternalOXtype.g:8443:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); 
+            }
+            // InternalOXtype.g:8444:2: ( rule__XSetLiteral__ElementsAssignment_3_1_1 )
+            // InternalOXtype.g:8444:3: rule__XSetLiteral__ElementsAssignment_3_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSetLiteral__ElementsAssignment_3_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getElementsAssignment_3_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__Group_3_1__1__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__0"
+    // InternalOXtype.g:8453:1: rule__XListLiteral__Group__0 : rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 ;
+    public final void rule__XListLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8457:1: ( rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1 )
+            // InternalOXtype.g:8458:2: rule__XListLiteral__Group__0__Impl rule__XListLiteral__Group__1
+            {
+            pushFollow(FOLLOW_18);
+            rule__XListLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__0__Impl"
+    // InternalOXtype.g:8465:1: rule__XListLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XListLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8469:1: ( ( () ) )
+            // InternalOXtype.g:8470:1: ( () )
+            {
+            // InternalOXtype.g:8470:1: ( () )
+            // InternalOXtype.g:8471:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); 
+            }
+            // InternalOXtype.g:8472:2: ()
+            // InternalOXtype.g:8472:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getXListLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__1"
+    // InternalOXtype.g:8480:1: rule__XListLiteral__Group__1 : rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 ;
+    public final void rule__XListLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8484:1: ( rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2 )
+            // InternalOXtype.g:8485:2: rule__XListLiteral__Group__1__Impl rule__XListLiteral__Group__2
+            {
+            pushFollow(FOLLOW_19);
+            rule__XListLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__1__Impl"
+    // InternalOXtype.g:8492:1: rule__XListLiteral__Group__1__Impl : ( '#' ) ;
+    public final void rule__XListLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8496:1: ( ( '#' ) )
+            // InternalOXtype.g:8497:1: ( '#' )
+            {
+            // InternalOXtype.g:8497:1: ( '#' )
+            // InternalOXtype.g:8498:2: '#'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); 
+            }
+            match(input,57,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__2"
+    // InternalOXtype.g:8507:1: rule__XListLiteral__Group__2 : rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 ;
+    public final void rule__XListLiteral__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8511:1: ( rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3 )
+            // InternalOXtype.g:8512:2: rule__XListLiteral__Group__2__Impl rule__XListLiteral__Group__3
+            {
+            pushFollow(FOLLOW_17);
+            rule__XListLiteral__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__2"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__2__Impl"
+    // InternalOXtype.g:8519:1: rule__XListLiteral__Group__2__Impl : ( '[' ) ;
+    public final void rule__XListLiteral__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8523:1: ( ( '[' ) )
+            // InternalOXtype.g:8524:1: ( '[' )
+            {
+            // InternalOXtype.g:8524:1: ( '[' )
+            // InternalOXtype.g:8525:2: '['
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); 
+            }
+            match(input,58,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__3"
+    // InternalOXtype.g:8534:1: rule__XListLiteral__Group__3 : rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 ;
+    public final void rule__XListLiteral__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8538:1: ( rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4 )
+            // InternalOXtype.g:8539:2: rule__XListLiteral__Group__3__Impl rule__XListLiteral__Group__4
+            {
+            pushFollow(FOLLOW_17);
+            rule__XListLiteral__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__3"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__3__Impl"
+    // InternalOXtype.g:8546:1: rule__XListLiteral__Group__3__Impl : ( ( rule__XListLiteral__Group_3__0 )? ) ;
+    public final void rule__XListLiteral__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8550:1: ( ( ( rule__XListLiteral__Group_3__0 )? ) )
+            // InternalOXtype.g:8551:1: ( ( rule__XListLiteral__Group_3__0 )? )
+            {
+            // InternalOXtype.g:8551:1: ( ( rule__XListLiteral__Group_3__0 )? )
+            // InternalOXtype.g:8552:2: ( rule__XListLiteral__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:8553:2: ( rule__XListLiteral__Group_3__0 )?
+            int alt76=2;
+            int LA76_0 = input.LA(1);
+
+            if ( ((LA76_0>=RULE_ID && LA76_0<=RULE_STRING)||LA76_0==27||(LA76_0>=34 && LA76_0<=35)||LA76_0==40||(LA76_0>=45 && LA76_0<=50)||LA76_0==53||(LA76_0>=57 && LA76_0<=58)||LA76_0==61||LA76_0==63||LA76_0==65||(LA76_0>=69 && LA76_0<=77)||LA76_0==79||LA76_0==88) ) {
+                alt76=1;
+            }
+            switch (alt76) {
+                case 1 :
+                    // InternalOXtype.g:8553:3: rule__XListLiteral__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XListLiteral__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__4"
+    // InternalOXtype.g:8561:1: rule__XListLiteral__Group__4 : rule__XListLiteral__Group__4__Impl ;
+    public final void rule__XListLiteral__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8565:1: ( rule__XListLiteral__Group__4__Impl )
+            // InternalOXtype.g:8566:2: rule__XListLiteral__Group__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__4"
+
+
+    // $ANTLR start "rule__XListLiteral__Group__4__Impl"
+    // InternalOXtype.g:8572:1: rule__XListLiteral__Group__4__Impl : ( ']' ) ;
+    public final void rule__XListLiteral__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8576:1: ( ( ']' ) )
+            // InternalOXtype.g:8577:1: ( ']' )
+            {
+            // InternalOXtype.g:8577:1: ( ']' )
+            // InternalOXtype.g:8578:2: ']'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); 
+            }
+            match(input,56,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3__0"
+    // InternalOXtype.g:8588:1: rule__XListLiteral__Group_3__0 : rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 ;
+    public final void rule__XListLiteral__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8592:1: ( rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1 )
+            // InternalOXtype.g:8593:2: rule__XListLiteral__Group_3__0__Impl rule__XListLiteral__Group_3__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XListLiteral__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3__0"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3__0__Impl"
+    // InternalOXtype.g:8600:1: rule__XListLiteral__Group_3__0__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) ;
+    public final void rule__XListLiteral__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8604:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_0 ) ) )
+            // InternalOXtype.g:8605:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) )
+            {
+            // InternalOXtype.g:8605:1: ( ( rule__XListLiteral__ElementsAssignment_3_0 ) )
+            // InternalOXtype.g:8606:2: ( rule__XListLiteral__ElementsAssignment_3_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); 
+            }
+            // InternalOXtype.g:8607:2: ( rule__XListLiteral__ElementsAssignment_3_0 )
+            // InternalOXtype.g:8607:3: rule__XListLiteral__ElementsAssignment_3_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__ElementsAssignment_3_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3__1"
+    // InternalOXtype.g:8615:1: rule__XListLiteral__Group_3__1 : rule__XListLiteral__Group_3__1__Impl ;
+    public final void rule__XListLiteral__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8619:1: ( rule__XListLiteral__Group_3__1__Impl )
+            // InternalOXtype.g:8620:2: rule__XListLiteral__Group_3__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3__1"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3__1__Impl"
+    // InternalOXtype.g:8626:1: rule__XListLiteral__Group_3__1__Impl : ( ( rule__XListLiteral__Group_3_1__0 )* ) ;
+    public final void rule__XListLiteral__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8630:1: ( ( ( rule__XListLiteral__Group_3_1__0 )* ) )
+            // InternalOXtype.g:8631:1: ( ( rule__XListLiteral__Group_3_1__0 )* )
+            {
+            // InternalOXtype.g:8631:1: ( ( rule__XListLiteral__Group_3_1__0 )* )
+            // InternalOXtype.g:8632:2: ( rule__XListLiteral__Group_3_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getGroup_3_1()); 
+            }
+            // InternalOXtype.g:8633:2: ( rule__XListLiteral__Group_3_1__0 )*
+            loop77:
+            do {
+                int alt77=2;
+                int LA77_0 = input.LA(1);
+
+                if ( (LA77_0==55) ) {
+                    alt77=1;
+                }
+
+
+                switch (alt77) {
+            	case 1 :
+            	    // InternalOXtype.g:8633:3: rule__XListLiteral__Group_3_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XListLiteral__Group_3_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop77;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getGroup_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3_1__0"
+    // InternalOXtype.g:8642:1: rule__XListLiteral__Group_3_1__0 : rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 ;
+    public final void rule__XListLiteral__Group_3_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8646:1: ( rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1 )
+            // InternalOXtype.g:8647:2: rule__XListLiteral__Group_3_1__0__Impl rule__XListLiteral__Group_3_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XListLiteral__Group_3_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group_3_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3_1__0"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3_1__0__Impl"
+    // InternalOXtype.g:8654:1: rule__XListLiteral__Group_3_1__0__Impl : ( ',' ) ;
+    public final void rule__XListLiteral__Group_3_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8658:1: ( ( ',' ) )
+            // InternalOXtype.g:8659:1: ( ',' )
+            {
+            // InternalOXtype.g:8659:1: ( ',' )
+            // InternalOXtype.g:8660:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3_1__0__Impl"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3_1__1"
+    // InternalOXtype.g:8669:1: rule__XListLiteral__Group_3_1__1 : rule__XListLiteral__Group_3_1__1__Impl ;
+    public final void rule__XListLiteral__Group_3_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8673:1: ( rule__XListLiteral__Group_3_1__1__Impl )
+            // InternalOXtype.g:8674:2: rule__XListLiteral__Group_3_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__Group_3_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3_1__1"
+
+
+    // $ANTLR start "rule__XListLiteral__Group_3_1__1__Impl"
+    // InternalOXtype.g:8680:1: rule__XListLiteral__Group_3_1__1__Impl : ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) ;
+    public final void rule__XListLiteral__Group_3_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8684:1: ( ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) ) )
+            // InternalOXtype.g:8685:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) )
+            {
+            // InternalOXtype.g:8685:1: ( ( rule__XListLiteral__ElementsAssignment_3_1_1 ) )
+            // InternalOXtype.g:8686:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); 
+            }
+            // InternalOXtype.g:8687:2: ( rule__XListLiteral__ElementsAssignment_3_1_1 )
+            // InternalOXtype.g:8687:3: rule__XListLiteral__ElementsAssignment_3_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XListLiteral__ElementsAssignment_3_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getElementsAssignment_3_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__Group_3_1__1__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group__0"
+    // InternalOXtype.g:8696:1: rule__XClosure__Group__0 : rule__XClosure__Group__0__Impl rule__XClosure__Group__1 ;
+    public final void rule__XClosure__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8700:1: ( rule__XClosure__Group__0__Impl rule__XClosure__Group__1 )
+            // InternalOXtype.g:8701:2: rule__XClosure__Group__0__Impl rule__XClosure__Group__1
+            {
+            pushFollow(FOLLOW_57);
+            rule__XClosure__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__0"
+
+
+    // $ANTLR start "rule__XClosure__Group__0__Impl"
+    // InternalOXtype.g:8708:1: rule__XClosure__Group__0__Impl : ( ( rule__XClosure__Group_0__0 ) ) ;
+    public final void rule__XClosure__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8712:1: ( ( ( rule__XClosure__Group_0__0 ) ) )
+            // InternalOXtype.g:8713:1: ( ( rule__XClosure__Group_0__0 ) )
+            {
+            // InternalOXtype.g:8713:1: ( ( rule__XClosure__Group_0__0 ) )
+            // InternalOXtype.g:8714:2: ( rule__XClosure__Group_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup_0()); 
+            }
+            // InternalOXtype.g:8715:2: ( rule__XClosure__Group_0__0 )
+            // InternalOXtype.g:8715:3: rule__XClosure__Group_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group__1"
+    // InternalOXtype.g:8723:1: rule__XClosure__Group__1 : rule__XClosure__Group__1__Impl rule__XClosure__Group__2 ;
+    public final void rule__XClosure__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8727:1: ( rule__XClosure__Group__1__Impl rule__XClosure__Group__2 )
+            // InternalOXtype.g:8728:2: rule__XClosure__Group__1__Impl rule__XClosure__Group__2
+            {
+            pushFollow(FOLLOW_57);
+            rule__XClosure__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__1"
+
+
+    // $ANTLR start "rule__XClosure__Group__1__Impl"
+    // InternalOXtype.g:8735:1: rule__XClosure__Group__1__Impl : ( ( rule__XClosure__Group_1__0 )? ) ;
+    public final void rule__XClosure__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8739:1: ( ( ( rule__XClosure__Group_1__0 )? ) )
+            // InternalOXtype.g:8740:1: ( ( rule__XClosure__Group_1__0 )? )
+            {
+            // InternalOXtype.g:8740:1: ( ( rule__XClosure__Group_1__0 )? )
+            // InternalOXtype.g:8741:2: ( rule__XClosure__Group_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:8742:2: ( rule__XClosure__Group_1__0 )?
+            int alt78=2;
+            alt78 = dfa78.predict(input);
+            switch (alt78) {
+                case 1 :
+                    // InternalOXtype.g:8742:3: rule__XClosure__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XClosure__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group__2"
+    // InternalOXtype.g:8750:1: rule__XClosure__Group__2 : rule__XClosure__Group__2__Impl rule__XClosure__Group__3 ;
+    public final void rule__XClosure__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8754:1: ( rule__XClosure__Group__2__Impl rule__XClosure__Group__3 )
+            // InternalOXtype.g:8755:2: rule__XClosure__Group__2__Impl rule__XClosure__Group__3
+            {
+            pushFollow(FOLLOW_58);
+            rule__XClosure__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__2"
+
+
+    // $ANTLR start "rule__XClosure__Group__2__Impl"
+    // InternalOXtype.g:8762:1: rule__XClosure__Group__2__Impl : ( ( rule__XClosure__ExpressionAssignment_2 ) ) ;
+    public final void rule__XClosure__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8766:1: ( ( ( rule__XClosure__ExpressionAssignment_2 ) ) )
+            // InternalOXtype.g:8767:1: ( ( rule__XClosure__ExpressionAssignment_2 ) )
+            {
+            // InternalOXtype.g:8767:1: ( ( rule__XClosure__ExpressionAssignment_2 ) )
+            // InternalOXtype.g:8768:2: ( rule__XClosure__ExpressionAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); 
+            }
+            // InternalOXtype.g:8769:2: ( rule__XClosure__ExpressionAssignment_2 )
+            // InternalOXtype.g:8769:3: rule__XClosure__ExpressionAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__ExpressionAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getExpressionAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group__3"
+    // InternalOXtype.g:8777:1: rule__XClosure__Group__3 : rule__XClosure__Group__3__Impl ;
+    public final void rule__XClosure__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8781:1: ( rule__XClosure__Group__3__Impl )
+            // InternalOXtype.g:8782:2: rule__XClosure__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__3"
+
+
+    // $ANTLR start "rule__XClosure__Group__3__Impl"
+    // InternalOXtype.g:8788:1: rule__XClosure__Group__3__Impl : ( ']' ) ;
+    public final void rule__XClosure__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8792:1: ( ( ']' ) )
+            // InternalOXtype.g:8793:1: ( ']' )
+            {
+            // InternalOXtype.g:8793:1: ( ']' )
+            // InternalOXtype.g:8794:2: ']'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); 
+            }
+            match(input,56,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_0__0"
+    // InternalOXtype.g:8804:1: rule__XClosure__Group_0__0 : rule__XClosure__Group_0__0__Impl ;
+    public final void rule__XClosure__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8808:1: ( rule__XClosure__Group_0__0__Impl )
+            // InternalOXtype.g:8809:2: rule__XClosure__Group_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_0__0"
+
+
+    // $ANTLR start "rule__XClosure__Group_0__0__Impl"
+    // InternalOXtype.g:8815:1: rule__XClosure__Group_0__0__Impl : ( ( rule__XClosure__Group_0_0__0 ) ) ;
+    public final void rule__XClosure__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8819:1: ( ( ( rule__XClosure__Group_0_0__0 ) ) )
+            // InternalOXtype.g:8820:1: ( ( rule__XClosure__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:8820:1: ( ( rule__XClosure__Group_0_0__0 ) )
+            // InternalOXtype.g:8821:2: ( rule__XClosure__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:8822:2: ( rule__XClosure__Group_0_0__0 )
+            // InternalOXtype.g:8822:3: rule__XClosure__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_0_0__0"
+    // InternalOXtype.g:8831:1: rule__XClosure__Group_0_0__0 : rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 ;
+    public final void rule__XClosure__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8835:1: ( rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1 )
+            // InternalOXtype.g:8836:2: rule__XClosure__Group_0_0__0__Impl rule__XClosure__Group_0_0__1
+            {
+            pushFollow(FOLLOW_19);
+            rule__XClosure__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XClosure__Group_0_0__0__Impl"
+    // InternalOXtype.g:8843:1: rule__XClosure__Group_0_0__0__Impl : ( () ) ;
+    public final void rule__XClosure__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8847:1: ( ( () ) )
+            // InternalOXtype.g:8848:1: ( () )
+            {
+            // InternalOXtype.g:8848:1: ( () )
+            // InternalOXtype.g:8849:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); 
+            }
+            // InternalOXtype.g:8850:2: ()
+            // InternalOXtype.g:8850:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getXClosureAction_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_0_0__1"
+    // InternalOXtype.g:8858:1: rule__XClosure__Group_0_0__1 : rule__XClosure__Group_0_0__1__Impl ;
+    public final void rule__XClosure__Group_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8862:1: ( rule__XClosure__Group_0_0__1__Impl )
+            // InternalOXtype.g:8863:2: rule__XClosure__Group_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_0_0__1"
+
+
+    // $ANTLR start "rule__XClosure__Group_0_0__1__Impl"
+    // InternalOXtype.g:8869:1: rule__XClosure__Group_0_0__1__Impl : ( '[' ) ;
+    public final void rule__XClosure__Group_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8873:1: ( ( '[' ) )
+            // InternalOXtype.g:8874:1: ( '[' )
+            {
+            // InternalOXtype.g:8874:1: ( '[' )
+            // InternalOXtype.g:8875:2: '['
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); 
+            }
+            match(input,58,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1__0"
+    // InternalOXtype.g:8885:1: rule__XClosure__Group_1__0 : rule__XClosure__Group_1__0__Impl ;
+    public final void rule__XClosure__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8889:1: ( rule__XClosure__Group_1__0__Impl )
+            // InternalOXtype.g:8890:2: rule__XClosure__Group_1__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1__0"
+
+
+    // $ANTLR start "rule__XClosure__Group_1__0__Impl"
+    // InternalOXtype.g:8896:1: rule__XClosure__Group_1__0__Impl : ( ( rule__XClosure__Group_1_0__0 ) ) ;
+    public final void rule__XClosure__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8900:1: ( ( ( rule__XClosure__Group_1_0__0 ) ) )
+            // InternalOXtype.g:8901:1: ( ( rule__XClosure__Group_1_0__0 ) )
+            {
+            // InternalOXtype.g:8901:1: ( ( rule__XClosure__Group_1_0__0 ) )
+            // InternalOXtype.g:8902:2: ( rule__XClosure__Group_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup_1_0()); 
+            }
+            // InternalOXtype.g:8903:2: ( rule__XClosure__Group_1_0__0 )
+            // InternalOXtype.g:8903:3: rule__XClosure__Group_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0__0"
+    // InternalOXtype.g:8912:1: rule__XClosure__Group_1_0__0 : rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 ;
+    public final void rule__XClosure__Group_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8916:1: ( rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1 )
+            // InternalOXtype.g:8917:2: rule__XClosure__Group_1_0__0__Impl rule__XClosure__Group_1_0__1
+            {
+            pushFollow(FOLLOW_59);
+            rule__XClosure__Group_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0__0"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0__0__Impl"
+    // InternalOXtype.g:8924:1: rule__XClosure__Group_1_0__0__Impl : ( ( rule__XClosure__Group_1_0_0__0 )? ) ;
+    public final void rule__XClosure__Group_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8928:1: ( ( ( rule__XClosure__Group_1_0_0__0 )? ) )
+            // InternalOXtype.g:8929:1: ( ( rule__XClosure__Group_1_0_0__0 )? )
+            {
+            // InternalOXtype.g:8929:1: ( ( rule__XClosure__Group_1_0_0__0 )? )
+            // InternalOXtype.g:8930:2: ( rule__XClosure__Group_1_0_0__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup_1_0_0()); 
+            }
+            // InternalOXtype.g:8931:2: ( rule__XClosure__Group_1_0_0__0 )?
+            int alt79=2;
+            int LA79_0 = input.LA(1);
+
+            if ( (LA79_0==RULE_ID||LA79_0==31||LA79_0==53) ) {
+                alt79=1;
+            }
+            switch (alt79) {
+                case 1 :
+                    // InternalOXtype.g:8931:3: rule__XClosure__Group_1_0_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XClosure__Group_1_0_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0__1"
+    // InternalOXtype.g:8939:1: rule__XClosure__Group_1_0__1 : rule__XClosure__Group_1_0__1__Impl ;
+    public final void rule__XClosure__Group_1_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8943:1: ( rule__XClosure__Group_1_0__1__Impl )
+            // InternalOXtype.g:8944:2: rule__XClosure__Group_1_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0__1"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0__1__Impl"
+    // InternalOXtype.g:8950:1: rule__XClosure__Group_1_0__1__Impl : ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) ;
+    public final void rule__XClosure__Group_1_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8954:1: ( ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) ) )
+            // InternalOXtype.g:8955:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) )
+            {
+            // InternalOXtype.g:8955:1: ( ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 ) )
+            // InternalOXtype.g:8956:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); 
+            }
+            // InternalOXtype.g:8957:2: ( rule__XClosure__ExplicitSyntaxAssignment_1_0_1 )
+            // InternalOXtype.g:8957:3: rule__XClosure__ExplicitSyntaxAssignment_1_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__ExplicitSyntaxAssignment_1_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getExplicitSyntaxAssignment_1_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0__1__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0__0"
+    // InternalOXtype.g:8966:1: rule__XClosure__Group_1_0_0__0 : rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 ;
+    public final void rule__XClosure__Group_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8970:1: ( rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1 )
+            // InternalOXtype.g:8971:2: rule__XClosure__Group_1_0_0__0__Impl rule__XClosure__Group_1_0_0__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XClosure__Group_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0__0"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0__0__Impl"
+    // InternalOXtype.g:8978:1: rule__XClosure__Group_1_0_0__0__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) ;
+    public final void rule__XClosure__Group_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8982:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) ) )
+            // InternalOXtype.g:8983:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) )
+            {
+            // InternalOXtype.g:8983:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 ) )
+            // InternalOXtype.g:8984:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); 
+            }
+            // InternalOXtype.g:8985:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 )
+            // InternalOXtype.g:8985:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0__1"
+    // InternalOXtype.g:8993:1: rule__XClosure__Group_1_0_0__1 : rule__XClosure__Group_1_0_0__1__Impl ;
+    public final void rule__XClosure__Group_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:8997:1: ( rule__XClosure__Group_1_0_0__1__Impl )
+            // InternalOXtype.g:8998:2: rule__XClosure__Group_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0__1"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0__1__Impl"
+    // InternalOXtype.g:9004:1: rule__XClosure__Group_1_0_0__1__Impl : ( ( rule__XClosure__Group_1_0_0_1__0 )* ) ;
+    public final void rule__XClosure__Group_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9008:1: ( ( ( rule__XClosure__Group_1_0_0_1__0 )* ) )
+            // InternalOXtype.g:9009:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* )
+            {
+            // InternalOXtype.g:9009:1: ( ( rule__XClosure__Group_1_0_0_1__0 )* )
+            // InternalOXtype.g:9010:2: ( rule__XClosure__Group_1_0_0_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); 
+            }
+            // InternalOXtype.g:9011:2: ( rule__XClosure__Group_1_0_0_1__0 )*
+            loop80:
+            do {
+                int alt80=2;
+                int LA80_0 = input.LA(1);
+
+                if ( (LA80_0==55) ) {
+                    alt80=1;
+                }
+
+
+                switch (alt80) {
+            	case 1 :
+            	    // InternalOXtype.g:9011:3: rule__XClosure__Group_1_0_0_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XClosure__Group_1_0_0_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop80;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getGroup_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0_1__0"
+    // InternalOXtype.g:9020:1: rule__XClosure__Group_1_0_0_1__0 : rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 ;
+    public final void rule__XClosure__Group_1_0_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9024:1: ( rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1 )
+            // InternalOXtype.g:9025:2: rule__XClosure__Group_1_0_0_1__0__Impl rule__XClosure__Group_1_0_0_1__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XClosure__Group_1_0_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0_1__0"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0_1__0__Impl"
+    // InternalOXtype.g:9032:1: rule__XClosure__Group_1_0_0_1__0__Impl : ( ',' ) ;
+    public final void rule__XClosure__Group_1_0_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9036:1: ( ( ',' ) )
+            // InternalOXtype.g:9037:1: ( ',' )
+            {
+            // InternalOXtype.g:9037:1: ( ',' )
+            // InternalOXtype.g:9038:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0_1__1"
+    // InternalOXtype.g:9047:1: rule__XClosure__Group_1_0_0_1__1 : rule__XClosure__Group_1_0_0_1__1__Impl ;
+    public final void rule__XClosure__Group_1_0_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9051:1: ( rule__XClosure__Group_1_0_0_1__1__Impl )
+            // InternalOXtype.g:9052:2: rule__XClosure__Group_1_0_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__Group_1_0_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0_1__1"
+
+
+    // $ANTLR start "rule__XClosure__Group_1_0_0_1__1__Impl"
+    // InternalOXtype.g:9058:1: rule__XClosure__Group_1_0_0_1__1__Impl : ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) ;
+    public final void rule__XClosure__Group_1_0_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9062:1: ( ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) ) )
+            // InternalOXtype.g:9063:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) )
+            {
+            // InternalOXtype.g:9063:1: ( ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 ) )
+            // InternalOXtype.g:9064:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); 
+            }
+            // InternalOXtype.g:9065:2: ( rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 )
+            // InternalOXtype.g:9065:3: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersAssignment_1_0_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__Group_1_0_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group__0"
+    // InternalOXtype.g:9074:1: rule__XExpressionInClosure__Group__0 : rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 ;
+    public final void rule__XExpressionInClosure__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9078:1: ( rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1 )
+            // InternalOXtype.g:9079:2: rule__XExpressionInClosure__Group__0__Impl rule__XExpressionInClosure__Group__1
+            {
+            pushFollow(FOLLOW_57);
+            rule__XExpressionInClosure__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XExpressionInClosure__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group__0"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group__0__Impl"
+    // InternalOXtype.g:9086:1: rule__XExpressionInClosure__Group__0__Impl : ( () ) ;
+    public final void rule__XExpressionInClosure__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9090:1: ( ( () ) )
+            // InternalOXtype.g:9091:1: ( () )
+            {
+            // InternalOXtype.g:9091:1: ( () )
+            // InternalOXtype.g:9092:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); 
+            }
+            // InternalOXtype.g:9093:2: ()
+            // InternalOXtype.g:9093:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group__1"
+    // InternalOXtype.g:9101:1: rule__XExpressionInClosure__Group__1 : rule__XExpressionInClosure__Group__1__Impl ;
+    public final void rule__XExpressionInClosure__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9105:1: ( rule__XExpressionInClosure__Group__1__Impl )
+            // InternalOXtype.g:9106:2: rule__XExpressionInClosure__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XExpressionInClosure__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group__1"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group__1__Impl"
+    // InternalOXtype.g:9112:1: rule__XExpressionInClosure__Group__1__Impl : ( ( rule__XExpressionInClosure__Group_1__0 )* ) ;
+    public final void rule__XExpressionInClosure__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9116:1: ( ( ( rule__XExpressionInClosure__Group_1__0 )* ) )
+            // InternalOXtype.g:9117:1: ( ( rule__XExpressionInClosure__Group_1__0 )* )
+            {
+            // InternalOXtype.g:9117:1: ( ( rule__XExpressionInClosure__Group_1__0 )* )
+            // InternalOXtype.g:9118:2: ( rule__XExpressionInClosure__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:9119:2: ( rule__XExpressionInClosure__Group_1__0 )*
+            loop81:
+            do {
+                int alt81=2;
+                int LA81_0 = input.LA(1);
+
+                if ( ((LA81_0>=RULE_ID && LA81_0<=RULE_STRING)||LA81_0==27||(LA81_0>=34 && LA81_0<=35)||LA81_0==40||(LA81_0>=44 && LA81_0<=50)||LA81_0==53||(LA81_0>=57 && LA81_0<=58)||LA81_0==61||LA81_0==63||LA81_0==65||(LA81_0>=69 && LA81_0<=77)||LA81_0==79||(LA81_0>=87 && LA81_0<=88)) ) {
+                    alt81=1;
+                }
+
+
+                switch (alt81) {
+            	case 1 :
+            	    // InternalOXtype.g:9119:3: rule__XExpressionInClosure__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_60);
+            	    rule__XExpressionInClosure__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop81;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group_1__0"
+    // InternalOXtype.g:9128:1: rule__XExpressionInClosure__Group_1__0 : rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 ;
+    public final void rule__XExpressionInClosure__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9132:1: ( rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1 )
+            // InternalOXtype.g:9133:2: rule__XExpressionInClosure__Group_1__0__Impl rule__XExpressionInClosure__Group_1__1
+            {
+            pushFollow(FOLLOW_6);
+            rule__XExpressionInClosure__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XExpressionInClosure__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group_1__0"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group_1__0__Impl"
+    // InternalOXtype.g:9140:1: rule__XExpressionInClosure__Group_1__0__Impl : ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) ;
+    public final void rule__XExpressionInClosure__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9144:1: ( ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) ) )
+            // InternalOXtype.g:9145:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) )
+            {
+            // InternalOXtype.g:9145:1: ( ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 ) )
+            // InternalOXtype.g:9146:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); 
+            }
+            // InternalOXtype.g:9147:2: ( rule__XExpressionInClosure__ExpressionsAssignment_1_0 )
+            // InternalOXtype.g:9147:3: rule__XExpressionInClosure__ExpressionsAssignment_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XExpressionInClosure__ExpressionsAssignment_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureAccess().getExpressionsAssignment_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group_1__1"
+    // InternalOXtype.g:9155:1: rule__XExpressionInClosure__Group_1__1 : rule__XExpressionInClosure__Group_1__1__Impl ;
+    public final void rule__XExpressionInClosure__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9159:1: ( rule__XExpressionInClosure__Group_1__1__Impl )
+            // InternalOXtype.g:9160:2: rule__XExpressionInClosure__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XExpressionInClosure__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group_1__1"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__Group_1__1__Impl"
+    // InternalOXtype.g:9166:1: rule__XExpressionInClosure__Group_1__1__Impl : ( ( ';' )? ) ;
+    public final void rule__XExpressionInClosure__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9170:1: ( ( ( ';' )? ) )
+            // InternalOXtype.g:9171:1: ( ( ';' )? )
+            {
+            // InternalOXtype.g:9171:1: ( ( ';' )? )
+            // InternalOXtype.g:9172:2: ( ';' )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); 
+            }
+            // InternalOXtype.g:9173:2: ( ';' )?
+            int alt82=2;
+            int LA82_0 = input.LA(1);
+
+            if ( (LA82_0==51) ) {
+                alt82=1;
+            }
+            switch (alt82) {
+                case 1 :
+                    // InternalOXtype.g:9173:3: ';'
+                    {
+                    match(input,51,FOLLOW_2); if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group__0"
+    // InternalOXtype.g:9182:1: rule__XShortClosure__Group__0 : rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 ;
+    public final void rule__XShortClosure__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9186:1: ( rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1 )
+            // InternalOXtype.g:9187:2: rule__XShortClosure__Group__0__Impl rule__XShortClosure__Group__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XShortClosure__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group__0"
+
+
+    // $ANTLR start "rule__XShortClosure__Group__0__Impl"
+    // InternalOXtype.g:9194:1: rule__XShortClosure__Group__0__Impl : ( ( rule__XShortClosure__Group_0__0 ) ) ;
+    public final void rule__XShortClosure__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9198:1: ( ( ( rule__XShortClosure__Group_0__0 ) ) )
+            // InternalOXtype.g:9199:1: ( ( rule__XShortClosure__Group_0__0 ) )
+            {
+            // InternalOXtype.g:9199:1: ( ( rule__XShortClosure__Group_0__0 ) )
+            // InternalOXtype.g:9200:2: ( rule__XShortClosure__Group_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getGroup_0()); 
+            }
+            // InternalOXtype.g:9201:2: ( rule__XShortClosure__Group_0__0 )
+            // InternalOXtype.g:9201:3: rule__XShortClosure__Group_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getGroup_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group__1"
+    // InternalOXtype.g:9209:1: rule__XShortClosure__Group__1 : rule__XShortClosure__Group__1__Impl ;
+    public final void rule__XShortClosure__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9213:1: ( rule__XShortClosure__Group__1__Impl )
+            // InternalOXtype.g:9214:2: rule__XShortClosure__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group__1"
+
+
+    // $ANTLR start "rule__XShortClosure__Group__1__Impl"
+    // InternalOXtype.g:9220:1: rule__XShortClosure__Group__1__Impl : ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) ;
+    public final void rule__XShortClosure__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9224:1: ( ( ( rule__XShortClosure__ExpressionAssignment_1 ) ) )
+            // InternalOXtype.g:9225:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) )
+            {
+            // InternalOXtype.g:9225:1: ( ( rule__XShortClosure__ExpressionAssignment_1 ) )
+            // InternalOXtype.g:9226:2: ( rule__XShortClosure__ExpressionAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); 
+            }
+            // InternalOXtype.g:9227:2: ( rule__XShortClosure__ExpressionAssignment_1 )
+            // InternalOXtype.g:9227:3: rule__XShortClosure__ExpressionAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__ExpressionAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getExpressionAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0__0"
+    // InternalOXtype.g:9236:1: rule__XShortClosure__Group_0__0 : rule__XShortClosure__Group_0__0__Impl ;
+    public final void rule__XShortClosure__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9240:1: ( rule__XShortClosure__Group_0__0__Impl )
+            // InternalOXtype.g:9241:2: rule__XShortClosure__Group_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0__0"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0__0__Impl"
+    // InternalOXtype.g:9247:1: rule__XShortClosure__Group_0__0__Impl : ( ( rule__XShortClosure__Group_0_0__0 ) ) ;
+    public final void rule__XShortClosure__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9251:1: ( ( ( rule__XShortClosure__Group_0_0__0 ) ) )
+            // InternalOXtype.g:9252:1: ( ( rule__XShortClosure__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:9252:1: ( ( rule__XShortClosure__Group_0_0__0 ) )
+            // InternalOXtype.g:9253:2: ( rule__XShortClosure__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:9254:2: ( rule__XShortClosure__Group_0_0__0 )
+            // InternalOXtype.g:9254:3: rule__XShortClosure__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0__0"
+    // InternalOXtype.g:9263:1: rule__XShortClosure__Group_0_0__0 : rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 ;
+    public final void rule__XShortClosure__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9267:1: ( rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1 )
+            // InternalOXtype.g:9268:2: rule__XShortClosure__Group_0_0__0__Impl rule__XShortClosure__Group_0_0__1
+            {
+            pushFollow(FOLLOW_59);
+            rule__XShortClosure__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0__0__Impl"
+    // InternalOXtype.g:9275:1: rule__XShortClosure__Group_0_0__0__Impl : ( () ) ;
+    public final void rule__XShortClosure__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9279:1: ( ( () ) )
+            // InternalOXtype.g:9280:1: ( () )
+            {
+            // InternalOXtype.g:9280:1: ( () )
+            // InternalOXtype.g:9281:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); 
+            }
+            // InternalOXtype.g:9282:2: ()
+            // InternalOXtype.g:9282:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0__1"
+    // InternalOXtype.g:9290:1: rule__XShortClosure__Group_0_0__1 : rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 ;
+    public final void rule__XShortClosure__Group_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9294:1: ( rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2 )
+            // InternalOXtype.g:9295:2: rule__XShortClosure__Group_0_0__1__Impl rule__XShortClosure__Group_0_0__2
+            {
+            pushFollow(FOLLOW_59);
+            rule__XShortClosure__Group_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0__1"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0__1__Impl"
+    // InternalOXtype.g:9302:1: rule__XShortClosure__Group_0_0__1__Impl : ( ( rule__XShortClosure__Group_0_0_1__0 )? ) ;
+    public final void rule__XShortClosure__Group_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9306:1: ( ( ( rule__XShortClosure__Group_0_0_1__0 )? ) )
+            // InternalOXtype.g:9307:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? )
+            {
+            // InternalOXtype.g:9307:1: ( ( rule__XShortClosure__Group_0_0_1__0 )? )
+            // InternalOXtype.g:9308:2: ( rule__XShortClosure__Group_0_0_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); 
+            }
+            // InternalOXtype.g:9309:2: ( rule__XShortClosure__Group_0_0_1__0 )?
+            int alt83=2;
+            int LA83_0 = input.LA(1);
+
+            if ( (LA83_0==RULE_ID||LA83_0==31||LA83_0==53) ) {
+                alt83=1;
+            }
+            switch (alt83) {
+                case 1 :
+                    // InternalOXtype.g:9309:3: rule__XShortClosure__Group_0_0_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XShortClosure__Group_0_0_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0__2"
+    // InternalOXtype.g:9317:1: rule__XShortClosure__Group_0_0__2 : rule__XShortClosure__Group_0_0__2__Impl ;
+    public final void rule__XShortClosure__Group_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9321:1: ( rule__XShortClosure__Group_0_0__2__Impl )
+            // InternalOXtype.g:9322:2: rule__XShortClosure__Group_0_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0__2"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0__2__Impl"
+    // InternalOXtype.g:9328:1: rule__XShortClosure__Group_0_0__2__Impl : ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) ;
+    public final void rule__XShortClosure__Group_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9332:1: ( ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) ) )
+            // InternalOXtype.g:9333:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) )
+            {
+            // InternalOXtype.g:9333:1: ( ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 ) )
+            // InternalOXtype.g:9334:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); 
+            }
+            // InternalOXtype.g:9335:2: ( rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 )
+            // InternalOXtype.g:9335:3: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxAssignment_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1__0"
+    // InternalOXtype.g:9344:1: rule__XShortClosure__Group_0_0_1__0 : rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 ;
+    public final void rule__XShortClosure__Group_0_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9348:1: ( rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1 )
+            // InternalOXtype.g:9349:2: rule__XShortClosure__Group_0_0_1__0__Impl rule__XShortClosure__Group_0_0_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XShortClosure__Group_0_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1__0"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1__0__Impl"
+    // InternalOXtype.g:9356:1: rule__XShortClosure__Group_0_0_1__0__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) ;
+    public final void rule__XShortClosure__Group_0_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9360:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) ) )
+            // InternalOXtype.g:9361:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) )
+            {
+            // InternalOXtype.g:9361:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 ) )
+            // InternalOXtype.g:9362:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); 
+            }
+            // InternalOXtype.g:9363:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 )
+            // InternalOXtype.g:9363:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1__1"
+    // InternalOXtype.g:9371:1: rule__XShortClosure__Group_0_0_1__1 : rule__XShortClosure__Group_0_0_1__1__Impl ;
+    public final void rule__XShortClosure__Group_0_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9375:1: ( rule__XShortClosure__Group_0_0_1__1__Impl )
+            // InternalOXtype.g:9376:2: rule__XShortClosure__Group_0_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1__1"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1__1__Impl"
+    // InternalOXtype.g:9382:1: rule__XShortClosure__Group_0_0_1__1__Impl : ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) ;
+    public final void rule__XShortClosure__Group_0_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9386:1: ( ( ( rule__XShortClosure__Group_0_0_1_1__0 )* ) )
+            // InternalOXtype.g:9387:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* )
+            {
+            // InternalOXtype.g:9387:1: ( ( rule__XShortClosure__Group_0_0_1_1__0 )* )
+            // InternalOXtype.g:9388:2: ( rule__XShortClosure__Group_0_0_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); 
+            }
+            // InternalOXtype.g:9389:2: ( rule__XShortClosure__Group_0_0_1_1__0 )*
+            loop84:
+            do {
+                int alt84=2;
+                int LA84_0 = input.LA(1);
+
+                if ( (LA84_0==55) ) {
+                    alt84=1;
+                }
+
+
+                switch (alt84) {
+            	case 1 :
+            	    // InternalOXtype.g:9389:3: rule__XShortClosure__Group_0_0_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XShortClosure__Group_0_0_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop84;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getGroup_0_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0"
+    // InternalOXtype.g:9398:1: rule__XShortClosure__Group_0_0_1_1__0 : rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 ;
+    public final void rule__XShortClosure__Group_0_0_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9402:1: ( rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1 )
+            // InternalOXtype.g:9403:2: rule__XShortClosure__Group_0_0_1_1__0__Impl rule__XShortClosure__Group_0_0_1_1__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XShortClosure__Group_0_0_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__0__Impl"
+    // InternalOXtype.g:9410:1: rule__XShortClosure__Group_0_0_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XShortClosure__Group_0_0_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9414:1: ( ( ',' ) )
+            // InternalOXtype.g:9415:1: ( ',' )
+            {
+            // InternalOXtype.g:9415:1: ( ',' )
+            // InternalOXtype.g:9416:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1"
+    // InternalOXtype.g:9425:1: rule__XShortClosure__Group_0_0_1_1__1 : rule__XShortClosure__Group_0_0_1_1__1__Impl ;
+    public final void rule__XShortClosure__Group_0_0_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9429:1: ( rule__XShortClosure__Group_0_0_1_1__1__Impl )
+            // InternalOXtype.g:9430:2: rule__XShortClosure__Group_0_0_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__Group_0_0_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1"
+
+
+    // $ANTLR start "rule__XShortClosure__Group_0_0_1_1__1__Impl"
+    // InternalOXtype.g:9436:1: rule__XShortClosure__Group_0_0_1_1__1__Impl : ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) ;
+    public final void rule__XShortClosure__Group_0_0_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9440:1: ( ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) ) )
+            // InternalOXtype.g:9441:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) )
+            {
+            // InternalOXtype.g:9441:1: ( ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 ) )
+            // InternalOXtype.g:9442:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); 
+            }
+            // InternalOXtype.g:9443:2: ( rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 )
+            // InternalOXtype.g:9443:3: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersAssignment_0_0_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__Group_0_0_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XParenthesizedExpression__Group__0"
+    // InternalOXtype.g:9452:1: rule__XParenthesizedExpression__Group__0 : rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 ;
+    public final void rule__XParenthesizedExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9456:1: ( rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1 )
+            // InternalOXtype.g:9457:2: rule__XParenthesizedExpression__Group__0__Impl rule__XParenthesizedExpression__Group__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XParenthesizedExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XParenthesizedExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XParenthesizedExpression__Group__0"
+
+
+    // $ANTLR start "rule__XParenthesizedExpression__Group__0__Impl"
+    // InternalOXtype.g:9464:1: rule__XParenthesizedExpression__Group__0__Impl : ( '(' ) ;
+    public final void rule__XParenthesizedExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9468:1: ( ( '(' ) )
+            // InternalOXtype.g:9469:1: ( '(' )
+            {
+            // InternalOXtype.g:9469:1: ( '(' )
+            // InternalOXtype.g:9470:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XParenthesizedExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XParenthesizedExpression__Group__1"
+    // InternalOXtype.g:9479:1: rule__XParenthesizedExpression__Group__1 : rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 ;
+    public final void rule__XParenthesizedExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9483:1: ( rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2 )
+            // InternalOXtype.g:9484:2: rule__XParenthesizedExpression__Group__1__Impl rule__XParenthesizedExpression__Group__2
+            {
+            pushFollow(FOLLOW_61);
+            rule__XParenthesizedExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XParenthesizedExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XParenthesizedExpression__Group__1"
+
+
+    // $ANTLR start "rule__XParenthesizedExpression__Group__1__Impl"
+    // InternalOXtype.g:9491:1: rule__XParenthesizedExpression__Group__1__Impl : ( ruleXExpression ) ;
+    public final void rule__XParenthesizedExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9495:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:9496:1: ( ruleXExpression )
+            {
+            // InternalOXtype.g:9496:1: ( ruleXExpression )
+            // InternalOXtype.g:9497:2: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XParenthesizedExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XParenthesizedExpression__Group__2"
+    // InternalOXtype.g:9506:1: rule__XParenthesizedExpression__Group__2 : rule__XParenthesizedExpression__Group__2__Impl ;
+    public final void rule__XParenthesizedExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9510:1: ( rule__XParenthesizedExpression__Group__2__Impl )
+            // InternalOXtype.g:9511:2: rule__XParenthesizedExpression__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XParenthesizedExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XParenthesizedExpression__Group__2"
+
+
+    // $ANTLR start "rule__XParenthesizedExpression__Group__2__Impl"
+    // InternalOXtype.g:9517:1: rule__XParenthesizedExpression__Group__2__Impl : ( ')' ) ;
+    public final void rule__XParenthesizedExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9521:1: ( ( ')' ) )
+            // InternalOXtype.g:9522:1: ( ')' )
+            {
+            // InternalOXtype.g:9522:1: ( ')' )
+            // InternalOXtype.g:9523:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XParenthesizedExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__0"
+    // InternalOXtype.g:9533:1: rule__XIfExpression__Group__0 : rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 ;
+    public final void rule__XIfExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9537:1: ( rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1 )
+            // InternalOXtype.g:9538:2: rule__XIfExpression__Group__0__Impl rule__XIfExpression__Group__1
+            {
+            pushFollow(FOLLOW_62);
+            rule__XIfExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__0"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__0__Impl"
+    // InternalOXtype.g:9545:1: rule__XIfExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XIfExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9549:1: ( ( () ) )
+            // InternalOXtype.g:9550:1: ( () )
+            {
+            // InternalOXtype.g:9550:1: ( () )
+            // InternalOXtype.g:9551:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); 
+            }
+            // InternalOXtype.g:9552:2: ()
+            // InternalOXtype.g:9552:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__1"
+    // InternalOXtype.g:9560:1: rule__XIfExpression__Group__1 : rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 ;
+    public final void rule__XIfExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9564:1: ( rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2 )
+            // InternalOXtype.g:9565:2: rule__XIfExpression__Group__1__Impl rule__XIfExpression__Group__2
+            {
+            pushFollow(FOLLOW_11);
+            rule__XIfExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__1"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__1__Impl"
+    // InternalOXtype.g:9572:1: rule__XIfExpression__Group__1__Impl : ( 'if' ) ;
+    public final void rule__XIfExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9576:1: ( ( 'if' ) )
+            // InternalOXtype.g:9577:1: ( 'if' )
+            {
+            // InternalOXtype.g:9577:1: ( 'if' )
+            // InternalOXtype.g:9578:2: 'if'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); 
+            }
+            match(input,63,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getIfKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__2"
+    // InternalOXtype.g:9587:1: rule__XIfExpression__Group__2 : rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 ;
+    public final void rule__XIfExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9591:1: ( rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3 )
+            // InternalOXtype.g:9592:2: rule__XIfExpression__Group__2__Impl rule__XIfExpression__Group__3
+            {
+            pushFollow(FOLLOW_15);
+            rule__XIfExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__2"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__2__Impl"
+    // InternalOXtype.g:9599:1: rule__XIfExpression__Group__2__Impl : ( '(' ) ;
+    public final void rule__XIfExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9603:1: ( ( '(' ) )
+            // InternalOXtype.g:9604:1: ( '(' )
+            {
+            // InternalOXtype.g:9604:1: ( '(' )
+            // InternalOXtype.g:9605:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__3"
+    // InternalOXtype.g:9614:1: rule__XIfExpression__Group__3 : rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 ;
+    public final void rule__XIfExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9618:1: ( rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4 )
+            // InternalOXtype.g:9619:2: rule__XIfExpression__Group__3__Impl rule__XIfExpression__Group__4
+            {
+            pushFollow(FOLLOW_61);
+            rule__XIfExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__3"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__3__Impl"
+    // InternalOXtype.g:9626:1: rule__XIfExpression__Group__3__Impl : ( ( rule__XIfExpression__IfAssignment_3 ) ) ;
+    public final void rule__XIfExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9630:1: ( ( ( rule__XIfExpression__IfAssignment_3 ) ) )
+            // InternalOXtype.g:9631:1: ( ( rule__XIfExpression__IfAssignment_3 ) )
+            {
+            // InternalOXtype.g:9631:1: ( ( rule__XIfExpression__IfAssignment_3 ) )
+            // InternalOXtype.g:9632:2: ( rule__XIfExpression__IfAssignment_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); 
+            }
+            // InternalOXtype.g:9633:2: ( rule__XIfExpression__IfAssignment_3 )
+            // InternalOXtype.g:9633:3: rule__XIfExpression__IfAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__IfAssignment_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getIfAssignment_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__4"
+    // InternalOXtype.g:9641:1: rule__XIfExpression__Group__4 : rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 ;
+    public final void rule__XIfExpression__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9645:1: ( rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5 )
+            // InternalOXtype.g:9646:2: rule__XIfExpression__Group__4__Impl rule__XIfExpression__Group__5
+            {
+            pushFollow(FOLLOW_15);
+            rule__XIfExpression__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__4"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__4__Impl"
+    // InternalOXtype.g:9653:1: rule__XIfExpression__Group__4__Impl : ( ')' ) ;
+    public final void rule__XIfExpression__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9657:1: ( ( ')' ) )
+            // InternalOXtype.g:9658:1: ( ')' )
+            {
+            // InternalOXtype.g:9658:1: ( ')' )
+            // InternalOXtype.g:9659:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__5"
+    // InternalOXtype.g:9668:1: rule__XIfExpression__Group__5 : rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 ;
+    public final void rule__XIfExpression__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9672:1: ( rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6 )
+            // InternalOXtype.g:9673:2: rule__XIfExpression__Group__5__Impl rule__XIfExpression__Group__6
+            {
+            pushFollow(FOLLOW_63);
+            rule__XIfExpression__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__6();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__5"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__5__Impl"
+    // InternalOXtype.g:9680:1: rule__XIfExpression__Group__5__Impl : ( ( rule__XIfExpression__ThenAssignment_5 ) ) ;
+    public final void rule__XIfExpression__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9684:1: ( ( ( rule__XIfExpression__ThenAssignment_5 ) ) )
+            // InternalOXtype.g:9685:1: ( ( rule__XIfExpression__ThenAssignment_5 ) )
+            {
+            // InternalOXtype.g:9685:1: ( ( rule__XIfExpression__ThenAssignment_5 ) )
+            // InternalOXtype.g:9686:2: ( rule__XIfExpression__ThenAssignment_5 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); 
+            }
+            // InternalOXtype.g:9687:2: ( rule__XIfExpression__ThenAssignment_5 )
+            // InternalOXtype.g:9687:3: rule__XIfExpression__ThenAssignment_5
+            {
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__ThenAssignment_5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getThenAssignment_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__6"
+    // InternalOXtype.g:9695:1: rule__XIfExpression__Group__6 : rule__XIfExpression__Group__6__Impl ;
+    public final void rule__XIfExpression__Group__6() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9699:1: ( rule__XIfExpression__Group__6__Impl )
+            // InternalOXtype.g:9700:2: rule__XIfExpression__Group__6__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group__6__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__6"
+
+
+    // $ANTLR start "rule__XIfExpression__Group__6__Impl"
+    // InternalOXtype.g:9706:1: rule__XIfExpression__Group__6__Impl : ( ( rule__XIfExpression__Group_6__0 )? ) ;
+    public final void rule__XIfExpression__Group__6__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9710:1: ( ( ( rule__XIfExpression__Group_6__0 )? ) )
+            // InternalOXtype.g:9711:1: ( ( rule__XIfExpression__Group_6__0 )? )
+            {
+            // InternalOXtype.g:9711:1: ( ( rule__XIfExpression__Group_6__0 )? )
+            // InternalOXtype.g:9712:2: ( rule__XIfExpression__Group_6__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getGroup_6()); 
+            }
+            // InternalOXtype.g:9713:2: ( rule__XIfExpression__Group_6__0 )?
+            int alt85=2;
+            int LA85_0 = input.LA(1);
+
+            if ( (LA85_0==64) ) {
+                int LA85_1 = input.LA(2);
+
+                if ( (synpred129_InternalOXtype()) ) {
+                    alt85=1;
+                }
+            }
+            switch (alt85) {
+                case 1 :
+                    // InternalOXtype.g:9713:3: rule__XIfExpression__Group_6__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XIfExpression__Group_6__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getGroup_6()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group__6__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group_6__0"
+    // InternalOXtype.g:9722:1: rule__XIfExpression__Group_6__0 : rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 ;
+    public final void rule__XIfExpression__Group_6__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9726:1: ( rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1 )
+            // InternalOXtype.g:9727:2: rule__XIfExpression__Group_6__0__Impl rule__XIfExpression__Group_6__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XIfExpression__Group_6__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group_6__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group_6__0"
+
+
+    // $ANTLR start "rule__XIfExpression__Group_6__0__Impl"
+    // InternalOXtype.g:9734:1: rule__XIfExpression__Group_6__0__Impl : ( ( 'else' ) ) ;
+    public final void rule__XIfExpression__Group_6__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9738:1: ( ( ( 'else' ) ) )
+            // InternalOXtype.g:9739:1: ( ( 'else' ) )
+            {
+            // InternalOXtype.g:9739:1: ( ( 'else' ) )
+            // InternalOXtype.g:9740:2: ( 'else' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); 
+            }
+            // InternalOXtype.g:9741:2: ( 'else' )
+            // InternalOXtype.g:9741:3: 'else'
+            {
+            match(input,64,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group_6__0__Impl"
+
+
+    // $ANTLR start "rule__XIfExpression__Group_6__1"
+    // InternalOXtype.g:9749:1: rule__XIfExpression__Group_6__1 : rule__XIfExpression__Group_6__1__Impl ;
+    public final void rule__XIfExpression__Group_6__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9753:1: ( rule__XIfExpression__Group_6__1__Impl )
+            // InternalOXtype.g:9754:2: rule__XIfExpression__Group_6__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__Group_6__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group_6__1"
+
+
+    // $ANTLR start "rule__XIfExpression__Group_6__1__Impl"
+    // InternalOXtype.g:9760:1: rule__XIfExpression__Group_6__1__Impl : ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) ;
+    public final void rule__XIfExpression__Group_6__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9764:1: ( ( ( rule__XIfExpression__ElseAssignment_6_1 ) ) )
+            // InternalOXtype.g:9765:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) )
+            {
+            // InternalOXtype.g:9765:1: ( ( rule__XIfExpression__ElseAssignment_6_1 ) )
+            // InternalOXtype.g:9766:2: ( rule__XIfExpression__ElseAssignment_6_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); 
+            }
+            // InternalOXtype.g:9767:2: ( rule__XIfExpression__ElseAssignment_6_1 )
+            // InternalOXtype.g:9767:3: rule__XIfExpression__ElseAssignment_6_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XIfExpression__ElseAssignment_6_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getElseAssignment_6_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__Group_6__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__0"
+    // InternalOXtype.g:9776:1: rule__XSwitchExpression__Group__0 : rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 ;
+    public final void rule__XSwitchExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9780:1: ( rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1 )
+            // InternalOXtype.g:9781:2: rule__XSwitchExpression__Group__0__Impl rule__XSwitchExpression__Group__1
+            {
+            pushFollow(FOLLOW_64);
+            rule__XSwitchExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__0__Impl"
+    // InternalOXtype.g:9788:1: rule__XSwitchExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XSwitchExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9792:1: ( ( () ) )
+            // InternalOXtype.g:9793:1: ( () )
+            {
+            // InternalOXtype.g:9793:1: ( () )
+            // InternalOXtype.g:9794:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); 
+            }
+            // InternalOXtype.g:9795:2: ()
+            // InternalOXtype.g:9795:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__1"
+    // InternalOXtype.g:9803:1: rule__XSwitchExpression__Group__1 : rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 ;
+    public final void rule__XSwitchExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9807:1: ( rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2 )
+            // InternalOXtype.g:9808:2: rule__XSwitchExpression__Group__1__Impl rule__XSwitchExpression__Group__2
+            {
+            pushFollow(FOLLOW_65);
+            rule__XSwitchExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__1__Impl"
+    // InternalOXtype.g:9815:1: rule__XSwitchExpression__Group__1__Impl : ( 'switch' ) ;
+    public final void rule__XSwitchExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9819:1: ( ( 'switch' ) )
+            // InternalOXtype.g:9820:1: ( 'switch' )
+            {
+            // InternalOXtype.g:9820:1: ( 'switch' )
+            // InternalOXtype.g:9821:2: 'switch'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); 
+            }
+            match(input,65,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__2"
+    // InternalOXtype.g:9830:1: rule__XSwitchExpression__Group__2 : rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 ;
+    public final void rule__XSwitchExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9834:1: ( rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3 )
+            // InternalOXtype.g:9835:2: rule__XSwitchExpression__Group__2__Impl rule__XSwitchExpression__Group__3
+            {
+            pushFollow(FOLLOW_55);
+            rule__XSwitchExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__2"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__2__Impl"
+    // InternalOXtype.g:9842:1: rule__XSwitchExpression__Group__2__Impl : ( ( rule__XSwitchExpression__Alternatives_2 ) ) ;
+    public final void rule__XSwitchExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9846:1: ( ( ( rule__XSwitchExpression__Alternatives_2 ) ) )
+            // InternalOXtype.g:9847:1: ( ( rule__XSwitchExpression__Alternatives_2 ) )
+            {
+            // InternalOXtype.g:9847:1: ( ( rule__XSwitchExpression__Alternatives_2 ) )
+            // InternalOXtype.g:9848:2: ( rule__XSwitchExpression__Alternatives_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); 
+            }
+            // InternalOXtype.g:9849:2: ( rule__XSwitchExpression__Alternatives_2 )
+            // InternalOXtype.g:9849:3: rule__XSwitchExpression__Alternatives_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Alternatives_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getAlternatives_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__3"
+    // InternalOXtype.g:9857:1: rule__XSwitchExpression__Group__3 : rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 ;
+    public final void rule__XSwitchExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9861:1: ( rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4 )
+            // InternalOXtype.g:9862:2: rule__XSwitchExpression__Group__3__Impl rule__XSwitchExpression__Group__4
+            {
+            pushFollow(FOLLOW_66);
+            rule__XSwitchExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__3"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__3__Impl"
+    // InternalOXtype.g:9869:1: rule__XSwitchExpression__Group__3__Impl : ( '{' ) ;
+    public final void rule__XSwitchExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9873:1: ( ( '{' ) )
+            // InternalOXtype.g:9874:1: ( '{' )
+            {
+            // InternalOXtype.g:9874:1: ( '{' )
+            // InternalOXtype.g:9875:2: '{'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); 
+            }
+            match(input,61,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__4"
+    // InternalOXtype.g:9884:1: rule__XSwitchExpression__Group__4 : rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 ;
+    public final void rule__XSwitchExpression__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9888:1: ( rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5 )
+            // InternalOXtype.g:9889:2: rule__XSwitchExpression__Group__4__Impl rule__XSwitchExpression__Group__5
+            {
+            pushFollow(FOLLOW_66);
+            rule__XSwitchExpression__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__4"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__4__Impl"
+    // InternalOXtype.g:9896:1: rule__XSwitchExpression__Group__4__Impl : ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) ;
+    public final void rule__XSwitchExpression__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9900:1: ( ( ( rule__XSwitchExpression__CasesAssignment_4 )* ) )
+            // InternalOXtype.g:9901:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* )
+            {
+            // InternalOXtype.g:9901:1: ( ( rule__XSwitchExpression__CasesAssignment_4 )* )
+            // InternalOXtype.g:9902:2: ( rule__XSwitchExpression__CasesAssignment_4 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); 
+            }
+            // InternalOXtype.g:9903:2: ( rule__XSwitchExpression__CasesAssignment_4 )*
+            loop86:
+            do {
+                int alt86=2;
+                int LA86_0 = input.LA(1);
+
+                if ( (LA86_0==RULE_ID||LA86_0==31||LA86_0==53||LA86_0==55||LA86_0==66||LA86_0==68) ) {
+                    alt86=1;
+                }
+
+
+                switch (alt86) {
+            	case 1 :
+            	    // InternalOXtype.g:9903:3: rule__XSwitchExpression__CasesAssignment_4
+            	    {
+            	    pushFollow(FOLLOW_67);
+            	    rule__XSwitchExpression__CasesAssignment_4();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop86;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getCasesAssignment_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__5"
+    // InternalOXtype.g:9911:1: rule__XSwitchExpression__Group__5 : rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 ;
+    public final void rule__XSwitchExpression__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9915:1: ( rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6 )
+            // InternalOXtype.g:9916:2: rule__XSwitchExpression__Group__5__Impl rule__XSwitchExpression__Group__6
+            {
+            pushFollow(FOLLOW_66);
+            rule__XSwitchExpression__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__6();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__5"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__5__Impl"
+    // InternalOXtype.g:9923:1: rule__XSwitchExpression__Group__5__Impl : ( ( rule__XSwitchExpression__Group_5__0 )? ) ;
+    public final void rule__XSwitchExpression__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9927:1: ( ( ( rule__XSwitchExpression__Group_5__0 )? ) )
+            // InternalOXtype.g:9928:1: ( ( rule__XSwitchExpression__Group_5__0 )? )
+            {
+            // InternalOXtype.g:9928:1: ( ( rule__XSwitchExpression__Group_5__0 )? )
+            // InternalOXtype.g:9929:2: ( rule__XSwitchExpression__Group_5__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); 
+            }
+            // InternalOXtype.g:9930:2: ( rule__XSwitchExpression__Group_5__0 )?
+            int alt87=2;
+            int LA87_0 = input.LA(1);
+
+            if ( (LA87_0==67) ) {
+                alt87=1;
+            }
+            switch (alt87) {
+                case 1 :
+                    // InternalOXtype.g:9930:3: rule__XSwitchExpression__Group_5__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XSwitchExpression__Group_5__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getGroup_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__6"
+    // InternalOXtype.g:9938:1: rule__XSwitchExpression__Group__6 : rule__XSwitchExpression__Group__6__Impl ;
+    public final void rule__XSwitchExpression__Group__6() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9942:1: ( rule__XSwitchExpression__Group__6__Impl )
+            // InternalOXtype.g:9943:2: rule__XSwitchExpression__Group__6__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group__6__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__6"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group__6__Impl"
+    // InternalOXtype.g:9949:1: rule__XSwitchExpression__Group__6__Impl : ( '}' ) ;
+    public final void rule__XSwitchExpression__Group__6__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9953:1: ( ( '}' ) )
+            // InternalOXtype.g:9954:1: ( '}' )
+            {
+            // InternalOXtype.g:9954:1: ( '}' )
+            // InternalOXtype.g:9955:2: '}'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); 
+            }
+            match(input,62,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group__6__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0__0"
+    // InternalOXtype.g:9965:1: rule__XSwitchExpression__Group_2_0__0 : rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 ;
+    public final void rule__XSwitchExpression__Group_2_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9969:1: ( rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1 )
+            // InternalOXtype.g:9970:2: rule__XSwitchExpression__Group_2_0__0__Impl rule__XSwitchExpression__Group_2_0__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XSwitchExpression__Group_2_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0__0__Impl"
+    // InternalOXtype.g:9977:1: rule__XSwitchExpression__Group_2_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9981:1: ( ( ( rule__XSwitchExpression__Group_2_0_0__0 ) ) )
+            // InternalOXtype.g:9982:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) )
+            {
+            // InternalOXtype.g:9982:1: ( ( rule__XSwitchExpression__Group_2_0_0__0 ) )
+            // InternalOXtype.g:9983:2: ( rule__XSwitchExpression__Group_2_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); 
+            }
+            // InternalOXtype.g:9984:2: ( rule__XSwitchExpression__Group_2_0_0__0 )
+            // InternalOXtype.g:9984:3: rule__XSwitchExpression__Group_2_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0__1"
+    // InternalOXtype.g:9992:1: rule__XSwitchExpression__Group_2_0__1 : rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 ;
+    public final void rule__XSwitchExpression__Group_2_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:9996:1: ( rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2 )
+            // InternalOXtype.g:9997:2: rule__XSwitchExpression__Group_2_0__1__Impl rule__XSwitchExpression__Group_2_0__2
+            {
+            pushFollow(FOLLOW_61);
+            rule__XSwitchExpression__Group_2_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0__1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0__1__Impl"
+    // InternalOXtype.g:10004:1: rule__XSwitchExpression__Group_2_0__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10008:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) ) )
+            // InternalOXtype.g:10009:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) )
+            {
+            // InternalOXtype.g:10009:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_0_1 ) )
+            // InternalOXtype.g:10010:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); 
+            }
+            // InternalOXtype.g:10011:2: ( rule__XSwitchExpression__SwitchAssignment_2_0_1 )
+            // InternalOXtype.g:10011:3: rule__XSwitchExpression__SwitchAssignment_2_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__SwitchAssignment_2_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0__2"
+    // InternalOXtype.g:10019:1: rule__XSwitchExpression__Group_2_0__2 : rule__XSwitchExpression__Group_2_0__2__Impl ;
+    public final void rule__XSwitchExpression__Group_2_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10023:1: ( rule__XSwitchExpression__Group_2_0__2__Impl )
+            // InternalOXtype.g:10024:2: rule__XSwitchExpression__Group_2_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0__2"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0__2__Impl"
+    // InternalOXtype.g:10030:1: rule__XSwitchExpression__Group_2_0__2__Impl : ( ')' ) ;
+    public final void rule__XSwitchExpression__Group_2_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10034:1: ( ( ')' ) )
+            // InternalOXtype.g:10035:1: ( ')' )
+            {
+            // InternalOXtype.g:10035:1: ( ')' )
+            // InternalOXtype.g:10036:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0__2__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0"
+    // InternalOXtype.g:10046:1: rule__XSwitchExpression__Group_2_0_0__0 : rule__XSwitchExpression__Group_2_0_0__0__Impl ;
+    public final void rule__XSwitchExpression__Group_2_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10050:1: ( rule__XSwitchExpression__Group_2_0_0__0__Impl )
+            // InternalOXtype.g:10051:2: rule__XSwitchExpression__Group_2_0_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0__0__Impl"
+    // InternalOXtype.g:10057:1: rule__XSwitchExpression__Group_2_0_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10061:1: ( ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) ) )
+            // InternalOXtype.g:10062:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) )
+            {
+            // InternalOXtype.g:10062:1: ( ( rule__XSwitchExpression__Group_2_0_0_0__0 ) )
+            // InternalOXtype.g:10063:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); 
+            }
+            // InternalOXtype.g:10064:2: ( rule__XSwitchExpression__Group_2_0_0_0__0 )
+            // InternalOXtype.g:10064:3: rule__XSwitchExpression__Group_2_0_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0"
+    // InternalOXtype.g:10073:1: rule__XSwitchExpression__Group_2_0_0_0__0 : rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 ;
+    public final void rule__XSwitchExpression__Group_2_0_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10077:1: ( rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1 )
+            // InternalOXtype.g:10078:2: rule__XSwitchExpression__Group_2_0_0_0__0__Impl rule__XSwitchExpression__Group_2_0_0_0__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XSwitchExpression__Group_2_0_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__0__Impl"
+    // InternalOXtype.g:10085:1: rule__XSwitchExpression__Group_2_0_0_0__0__Impl : ( '(' ) ;
+    public final void rule__XSwitchExpression__Group_2_0_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10089:1: ( ( '(' ) )
+            // InternalOXtype.g:10090:1: ( '(' )
+            {
+            // InternalOXtype.g:10090:1: ( '(' )
+            // InternalOXtype.g:10091:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1"
+    // InternalOXtype.g:10100:1: rule__XSwitchExpression__Group_2_0_0_0__1 : rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 ;
+    public final void rule__XSwitchExpression__Group_2_0_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10104:1: ( rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2 )
+            // InternalOXtype.g:10105:2: rule__XSwitchExpression__Group_2_0_0_0__1__Impl rule__XSwitchExpression__Group_2_0_0_0__2
+            {
+            pushFollow(FOLLOW_68);
+            rule__XSwitchExpression__Group_2_0_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__1__Impl"
+    // InternalOXtype.g:10112:1: rule__XSwitchExpression__Group_2_0_0_0__1__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_0_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10116:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) ) )
+            // InternalOXtype.g:10117:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) )
+            {
+            // InternalOXtype.g:10117:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 ) )
+            // InternalOXtype.g:10118:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); 
+            }
+            // InternalOXtype.g:10119:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 )
+            // InternalOXtype.g:10119:3: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_0_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2"
+    // InternalOXtype.g:10127:1: rule__XSwitchExpression__Group_2_0_0_0__2 : rule__XSwitchExpression__Group_2_0_0_0__2__Impl ;
+    public final void rule__XSwitchExpression__Group_2_0_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10131:1: ( rule__XSwitchExpression__Group_2_0_0_0__2__Impl )
+            // InternalOXtype.g:10132:2: rule__XSwitchExpression__Group_2_0_0_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_0_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_0_0_0__2__Impl"
+    // InternalOXtype.g:10138:1: rule__XSwitchExpression__Group_2_0_0_0__2__Impl : ( ':' ) ;
+    public final void rule__XSwitchExpression__Group_2_0_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10142:1: ( ( ':' ) )
+            // InternalOXtype.g:10143:1: ( ':' )
+            {
+            // InternalOXtype.g:10143:1: ( ':' )
+            // InternalOXtype.g:10144:2: ':'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); 
+            }
+            match(input,66,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_0_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1__0"
+    // InternalOXtype.g:10154:1: rule__XSwitchExpression__Group_2_1__0 : rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 ;
+    public final void rule__XSwitchExpression__Group_2_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10158:1: ( rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1 )
+            // InternalOXtype.g:10159:2: rule__XSwitchExpression__Group_2_1__0__Impl rule__XSwitchExpression__Group_2_1__1
+            {
+            pushFollow(FOLLOW_65);
+            rule__XSwitchExpression__Group_2_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1__0__Impl"
+    // InternalOXtype.g:10166:1: rule__XSwitchExpression__Group_2_1__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) ;
+    public final void rule__XSwitchExpression__Group_2_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10170:1: ( ( ( rule__XSwitchExpression__Group_2_1_0__0 )? ) )
+            // InternalOXtype.g:10171:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? )
+            {
+            // InternalOXtype.g:10171:1: ( ( rule__XSwitchExpression__Group_2_1_0__0 )? )
+            // InternalOXtype.g:10172:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); 
+            }
+            // InternalOXtype.g:10173:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?
+            int alt88=2;
+            alt88 = dfa88.predict(input);
+            switch (alt88) {
+                case 1 :
+                    // InternalOXtype.g:10173:3: rule__XSwitchExpression__Group_2_1_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XSwitchExpression__Group_2_1_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1__1"
+    // InternalOXtype.g:10181:1: rule__XSwitchExpression__Group_2_1__1 : rule__XSwitchExpression__Group_2_1__1__Impl ;
+    public final void rule__XSwitchExpression__Group_2_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10185:1: ( rule__XSwitchExpression__Group_2_1__1__Impl )
+            // InternalOXtype.g:10186:2: rule__XSwitchExpression__Group_2_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1__1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1__1__Impl"
+    // InternalOXtype.g:10192:1: rule__XSwitchExpression__Group_2_1__1__Impl : ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10196:1: ( ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) ) )
+            // InternalOXtype.g:10197:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) )
+            {
+            // InternalOXtype.g:10197:1: ( ( rule__XSwitchExpression__SwitchAssignment_2_1_1 ) )
+            // InternalOXtype.g:10198:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); 
+            }
+            // InternalOXtype.g:10199:2: ( rule__XSwitchExpression__SwitchAssignment_2_1_1 )
+            // InternalOXtype.g:10199:3: rule__XSwitchExpression__SwitchAssignment_2_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__SwitchAssignment_2_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getSwitchAssignment_2_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0"
+    // InternalOXtype.g:10208:1: rule__XSwitchExpression__Group_2_1_0__0 : rule__XSwitchExpression__Group_2_1_0__0__Impl ;
+    public final void rule__XSwitchExpression__Group_2_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10212:1: ( rule__XSwitchExpression__Group_2_1_0__0__Impl )
+            // InternalOXtype.g:10213:2: rule__XSwitchExpression__Group_2_1_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1_0__0__Impl"
+    // InternalOXtype.g:10219:1: rule__XSwitchExpression__Group_2_1_0__0__Impl : ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10223:1: ( ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) ) )
+            // InternalOXtype.g:10224:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) )
+            {
+            // InternalOXtype.g:10224:1: ( ( rule__XSwitchExpression__Group_2_1_0_0__0 ) )
+            // InternalOXtype.g:10225:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); 
+            }
+            // InternalOXtype.g:10226:2: ( rule__XSwitchExpression__Group_2_1_0_0__0 )
+            // InternalOXtype.g:10226:3: rule__XSwitchExpression__Group_2_1_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_1_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getGroup_2_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0"
+    // InternalOXtype.g:10235:1: rule__XSwitchExpression__Group_2_1_0_0__0 : rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 ;
+    public final void rule__XSwitchExpression__Group_2_1_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10239:1: ( rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1 )
+            // InternalOXtype.g:10240:2: rule__XSwitchExpression__Group_2_1_0_0__0__Impl rule__XSwitchExpression__Group_2_1_0_0__1
+            {
+            pushFollow(FOLLOW_68);
+            rule__XSwitchExpression__Group_2_1_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_1_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__0__Impl"
+    // InternalOXtype.g:10247:1: rule__XSwitchExpression__Group_2_1_0_0__0__Impl : ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) ;
+    public final void rule__XSwitchExpression__Group_2_1_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10251:1: ( ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) ) )
+            // InternalOXtype.g:10252:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) )
+            {
+            // InternalOXtype.g:10252:1: ( ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 ) )
+            // InternalOXtype.g:10253:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); 
+            }
+            // InternalOXtype.g:10254:2: ( rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 )
+            // InternalOXtype.g:10254:3: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamAssignment_2_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1"
+    // InternalOXtype.g:10262:1: rule__XSwitchExpression__Group_2_1_0_0__1 : rule__XSwitchExpression__Group_2_1_0_0__1__Impl ;
+    public final void rule__XSwitchExpression__Group_2_1_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10266:1: ( rule__XSwitchExpression__Group_2_1_0_0__1__Impl )
+            // InternalOXtype.g:10267:2: rule__XSwitchExpression__Group_2_1_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_2_1_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_2_1_0_0__1__Impl"
+    // InternalOXtype.g:10273:1: rule__XSwitchExpression__Group_2_1_0_0__1__Impl : ( ':' ) ;
+    public final void rule__XSwitchExpression__Group_2_1_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10277:1: ( ( ':' ) )
+            // InternalOXtype.g:10278:1: ( ':' )
+            {
+            // InternalOXtype.g:10278:1: ( ':' )
+            // InternalOXtype.g:10279:2: ':'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); 
+            }
+            match(input,66,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_2_1_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_5__0"
+    // InternalOXtype.g:10289:1: rule__XSwitchExpression__Group_5__0 : rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 ;
+    public final void rule__XSwitchExpression__Group_5__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10293:1: ( rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1 )
+            // InternalOXtype.g:10294:2: rule__XSwitchExpression__Group_5__0__Impl rule__XSwitchExpression__Group_5__1
+            {
+            pushFollow(FOLLOW_68);
+            rule__XSwitchExpression__Group_5__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_5__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_5__0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_5__0__Impl"
+    // InternalOXtype.g:10301:1: rule__XSwitchExpression__Group_5__0__Impl : ( 'default' ) ;
+    public final void rule__XSwitchExpression__Group_5__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10305:1: ( ( 'default' ) )
+            // InternalOXtype.g:10306:1: ( 'default' )
+            {
+            // InternalOXtype.g:10306:1: ( 'default' )
+            // InternalOXtype.g:10307:2: 'default'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); 
+            }
+            match(input,67,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_5__0__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_5__1"
+    // InternalOXtype.g:10316:1: rule__XSwitchExpression__Group_5__1 : rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 ;
+    public final void rule__XSwitchExpression__Group_5__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10320:1: ( rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2 )
+            // InternalOXtype.g:10321:2: rule__XSwitchExpression__Group_5__1__Impl rule__XSwitchExpression__Group_5__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__XSwitchExpression__Group_5__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_5__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_5__1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_5__1__Impl"
+    // InternalOXtype.g:10328:1: rule__XSwitchExpression__Group_5__1__Impl : ( ':' ) ;
+    public final void rule__XSwitchExpression__Group_5__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10332:1: ( ( ':' ) )
+            // InternalOXtype.g:10333:1: ( ':' )
+            {
+            // InternalOXtype.g:10333:1: ( ':' )
+            // InternalOXtype.g:10334:2: ':'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); 
+            }
+            match(input,66,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_5__1__Impl"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_5__2"
+    // InternalOXtype.g:10343:1: rule__XSwitchExpression__Group_5__2 : rule__XSwitchExpression__Group_5__2__Impl ;
+    public final void rule__XSwitchExpression__Group_5__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10347:1: ( rule__XSwitchExpression__Group_5__2__Impl )
+            // InternalOXtype.g:10348:2: rule__XSwitchExpression__Group_5__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__Group_5__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_5__2"
+
+
+    // $ANTLR start "rule__XSwitchExpression__Group_5__2__Impl"
+    // InternalOXtype.g:10354:1: rule__XSwitchExpression__Group_5__2__Impl : ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) ;
+    public final void rule__XSwitchExpression__Group_5__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10358:1: ( ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) ) )
+            // InternalOXtype.g:10359:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) )
+            {
+            // InternalOXtype.g:10359:1: ( ( rule__XSwitchExpression__DefaultAssignment_5_2 ) )
+            // InternalOXtype.g:10360:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); 
+            }
+            // InternalOXtype.g:10361:2: ( rule__XSwitchExpression__DefaultAssignment_5_2 )
+            // InternalOXtype.g:10361:3: rule__XSwitchExpression__DefaultAssignment_5_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSwitchExpression__DefaultAssignment_5_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDefaultAssignment_5_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__Group_5__2__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group__0"
+    // InternalOXtype.g:10370:1: rule__XCasePart__Group__0 : rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 ;
+    public final void rule__XCasePart__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10374:1: ( rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1 )
+            // InternalOXtype.g:10375:2: rule__XCasePart__Group__0__Impl rule__XCasePart__Group__1
+            {
+            pushFollow(FOLLOW_69);
+            rule__XCasePart__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__0"
+
+
+    // $ANTLR start "rule__XCasePart__Group__0__Impl"
+    // InternalOXtype.g:10382:1: rule__XCasePart__Group__0__Impl : ( () ) ;
+    public final void rule__XCasePart__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10386:1: ( ( () ) )
+            // InternalOXtype.g:10387:1: ( () )
+            {
+            // InternalOXtype.g:10387:1: ( () )
+            // InternalOXtype.g:10388:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); 
+            }
+            // InternalOXtype.g:10389:2: ()
+            // InternalOXtype.g:10389:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getXCasePartAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group__1"
+    // InternalOXtype.g:10397:1: rule__XCasePart__Group__1 : rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 ;
+    public final void rule__XCasePart__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10401:1: ( rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2 )
+            // InternalOXtype.g:10402:2: rule__XCasePart__Group__1__Impl rule__XCasePart__Group__2
+            {
+            pushFollow(FOLLOW_69);
+            rule__XCasePart__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__1"
+
+
+    // $ANTLR start "rule__XCasePart__Group__1__Impl"
+    // InternalOXtype.g:10409:1: rule__XCasePart__Group__1__Impl : ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) ;
+    public final void rule__XCasePart__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10413:1: ( ( ( rule__XCasePart__TypeGuardAssignment_1 )? ) )
+            // InternalOXtype.g:10414:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? )
+            {
+            // InternalOXtype.g:10414:1: ( ( rule__XCasePart__TypeGuardAssignment_1 )? )
+            // InternalOXtype.g:10415:2: ( rule__XCasePart__TypeGuardAssignment_1 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); 
+            }
+            // InternalOXtype.g:10416:2: ( rule__XCasePart__TypeGuardAssignment_1 )?
+            int alt89=2;
+            int LA89_0 = input.LA(1);
+
+            if ( (LA89_0==RULE_ID||LA89_0==31||LA89_0==53) ) {
+                alt89=1;
+            }
+            switch (alt89) {
+                case 1 :
+                    // InternalOXtype.g:10416:3: rule__XCasePart__TypeGuardAssignment_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XCasePart__TypeGuardAssignment_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getTypeGuardAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group__2"
+    // InternalOXtype.g:10424:1: rule__XCasePart__Group__2 : rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 ;
+    public final void rule__XCasePart__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10428:1: ( rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3 )
+            // InternalOXtype.g:10429:2: rule__XCasePart__Group__2__Impl rule__XCasePart__Group__3
+            {
+            pushFollow(FOLLOW_69);
+            rule__XCasePart__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__2"
+
+
+    // $ANTLR start "rule__XCasePart__Group__2__Impl"
+    // InternalOXtype.g:10436:1: rule__XCasePart__Group__2__Impl : ( ( rule__XCasePart__Group_2__0 )? ) ;
+    public final void rule__XCasePart__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10440:1: ( ( ( rule__XCasePart__Group_2__0 )? ) )
+            // InternalOXtype.g:10441:1: ( ( rule__XCasePart__Group_2__0 )? )
+            {
+            // InternalOXtype.g:10441:1: ( ( rule__XCasePart__Group_2__0 )? )
+            // InternalOXtype.g:10442:2: ( rule__XCasePart__Group_2__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getGroup_2()); 
+            }
+            // InternalOXtype.g:10443:2: ( rule__XCasePart__Group_2__0 )?
+            int alt90=2;
+            int LA90_0 = input.LA(1);
+
+            if ( (LA90_0==68) ) {
+                alt90=1;
+            }
+            switch (alt90) {
+                case 1 :
+                    // InternalOXtype.g:10443:3: rule__XCasePart__Group_2__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XCasePart__Group_2__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getGroup_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group__3"
+    // InternalOXtype.g:10451:1: rule__XCasePart__Group__3 : rule__XCasePart__Group__3__Impl ;
+    public final void rule__XCasePart__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10455:1: ( rule__XCasePart__Group__3__Impl )
+            // InternalOXtype.g:10456:2: rule__XCasePart__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__3"
+
+
+    // $ANTLR start "rule__XCasePart__Group__3__Impl"
+    // InternalOXtype.g:10462:1: rule__XCasePart__Group__3__Impl : ( ( rule__XCasePart__Alternatives_3 ) ) ;
+    public final void rule__XCasePart__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10466:1: ( ( ( rule__XCasePart__Alternatives_3 ) ) )
+            // InternalOXtype.g:10467:1: ( ( rule__XCasePart__Alternatives_3 ) )
+            {
+            // InternalOXtype.g:10467:1: ( ( rule__XCasePart__Alternatives_3 ) )
+            // InternalOXtype.g:10468:2: ( rule__XCasePart__Alternatives_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getAlternatives_3()); 
+            }
+            // InternalOXtype.g:10469:2: ( rule__XCasePart__Alternatives_3 )
+            // InternalOXtype.g:10469:3: rule__XCasePart__Alternatives_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Alternatives_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getAlternatives_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group_2__0"
+    // InternalOXtype.g:10478:1: rule__XCasePart__Group_2__0 : rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 ;
+    public final void rule__XCasePart__Group_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10482:1: ( rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1 )
+            // InternalOXtype.g:10483:2: rule__XCasePart__Group_2__0__Impl rule__XCasePart__Group_2__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XCasePart__Group_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_2__0"
+
+
+    // $ANTLR start "rule__XCasePart__Group_2__0__Impl"
+    // InternalOXtype.g:10490:1: rule__XCasePart__Group_2__0__Impl : ( 'case' ) ;
+    public final void rule__XCasePart__Group_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10494:1: ( ( 'case' ) )
+            // InternalOXtype.g:10495:1: ( 'case' )
+            {
+            // InternalOXtype.g:10495:1: ( 'case' )
+            // InternalOXtype.g:10496:2: 'case'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); 
+            }
+            match(input,68,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getCaseKeyword_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_2__0__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group_2__1"
+    // InternalOXtype.g:10505:1: rule__XCasePart__Group_2__1 : rule__XCasePart__Group_2__1__Impl ;
+    public final void rule__XCasePart__Group_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10509:1: ( rule__XCasePart__Group_2__1__Impl )
+            // InternalOXtype.g:10510:2: rule__XCasePart__Group_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_2__1"
+
+
+    // $ANTLR start "rule__XCasePart__Group_2__1__Impl"
+    // InternalOXtype.g:10516:1: rule__XCasePart__Group_2__1__Impl : ( ( rule__XCasePart__CaseAssignment_2_1 ) ) ;
+    public final void rule__XCasePart__Group_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10520:1: ( ( ( rule__XCasePart__CaseAssignment_2_1 ) ) )
+            // InternalOXtype.g:10521:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) )
+            {
+            // InternalOXtype.g:10521:1: ( ( rule__XCasePart__CaseAssignment_2_1 ) )
+            // InternalOXtype.g:10522:2: ( rule__XCasePart__CaseAssignment_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); 
+            }
+            // InternalOXtype.g:10523:2: ( rule__XCasePart__CaseAssignment_2_1 )
+            // InternalOXtype.g:10523:3: rule__XCasePart__CaseAssignment_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__CaseAssignment_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getCaseAssignment_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_2__1__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group_3_0__0"
+    // InternalOXtype.g:10532:1: rule__XCasePart__Group_3_0__0 : rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 ;
+    public final void rule__XCasePart__Group_3_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10536:1: ( rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1 )
+            // InternalOXtype.g:10537:2: rule__XCasePart__Group_3_0__0__Impl rule__XCasePart__Group_3_0__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XCasePart__Group_3_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group_3_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_3_0__0"
+
+
+    // $ANTLR start "rule__XCasePart__Group_3_0__0__Impl"
+    // InternalOXtype.g:10544:1: rule__XCasePart__Group_3_0__0__Impl : ( ':' ) ;
+    public final void rule__XCasePart__Group_3_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10548:1: ( ( ':' ) )
+            // InternalOXtype.g:10549:1: ( ':' )
+            {
+            // InternalOXtype.g:10549:1: ( ':' )
+            // InternalOXtype.g:10550:2: ':'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); 
+            }
+            match(input,66,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_3_0__0__Impl"
+
+
+    // $ANTLR start "rule__XCasePart__Group_3_0__1"
+    // InternalOXtype.g:10559:1: rule__XCasePart__Group_3_0__1 : rule__XCasePart__Group_3_0__1__Impl ;
+    public final void rule__XCasePart__Group_3_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10563:1: ( rule__XCasePart__Group_3_0__1__Impl )
+            // InternalOXtype.g:10564:2: rule__XCasePart__Group_3_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__Group_3_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_3_0__1"
+
+
+    // $ANTLR start "rule__XCasePart__Group_3_0__1__Impl"
+    // InternalOXtype.g:10570:1: rule__XCasePart__Group_3_0__1__Impl : ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) ;
+    public final void rule__XCasePart__Group_3_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10574:1: ( ( ( rule__XCasePart__ThenAssignment_3_0_1 ) ) )
+            // InternalOXtype.g:10575:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) )
+            {
+            // InternalOXtype.g:10575:1: ( ( rule__XCasePart__ThenAssignment_3_0_1 ) )
+            // InternalOXtype.g:10576:2: ( rule__XCasePart__ThenAssignment_3_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); 
+            }
+            // InternalOXtype.g:10577:2: ( rule__XCasePart__ThenAssignment_3_0_1 )
+            // InternalOXtype.g:10577:3: rule__XCasePart__ThenAssignment_3_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCasePart__ThenAssignment_3_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getThenAssignment_3_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__Group_3_0__1__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__0"
+    // InternalOXtype.g:10586:1: rule__XForLoopExpression__Group__0 : rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 ;
+    public final void rule__XForLoopExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10590:1: ( rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1 )
+            // InternalOXtype.g:10591:2: rule__XForLoopExpression__Group__0__Impl rule__XForLoopExpression__Group__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XForLoopExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__0"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__0__Impl"
+    // InternalOXtype.g:10598:1: rule__XForLoopExpression__Group__0__Impl : ( ( rule__XForLoopExpression__Group_0__0 ) ) ;
+    public final void rule__XForLoopExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10602:1: ( ( ( rule__XForLoopExpression__Group_0__0 ) ) )
+            // InternalOXtype.g:10603:1: ( ( rule__XForLoopExpression__Group_0__0 ) )
+            {
+            // InternalOXtype.g:10603:1: ( ( rule__XForLoopExpression__Group_0__0 ) )
+            // InternalOXtype.g:10604:2: ( rule__XForLoopExpression__Group_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); 
+            }
+            // InternalOXtype.g:10605:2: ( rule__XForLoopExpression__Group_0__0 )
+            // InternalOXtype.g:10605:3: rule__XForLoopExpression__Group_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getGroup_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__1"
+    // InternalOXtype.g:10613:1: rule__XForLoopExpression__Group__1 : rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 ;
+    public final void rule__XForLoopExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10617:1: ( rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2 )
+            // InternalOXtype.g:10618:2: rule__XForLoopExpression__Group__1__Impl rule__XForLoopExpression__Group__2
+            {
+            pushFollow(FOLLOW_61);
+            rule__XForLoopExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__1"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__1__Impl"
+    // InternalOXtype.g:10625:1: rule__XForLoopExpression__Group__1__Impl : ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) ;
+    public final void rule__XForLoopExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10629:1: ( ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) ) )
+            // InternalOXtype.g:10630:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) )
+            {
+            // InternalOXtype.g:10630:1: ( ( rule__XForLoopExpression__ForExpressionAssignment_1 ) )
+            // InternalOXtype.g:10631:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); 
+            }
+            // InternalOXtype.g:10632:2: ( rule__XForLoopExpression__ForExpressionAssignment_1 )
+            // InternalOXtype.g:10632:3: rule__XForLoopExpression__ForExpressionAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__ForExpressionAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getForExpressionAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__2"
+    // InternalOXtype.g:10640:1: rule__XForLoopExpression__Group__2 : rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 ;
+    public final void rule__XForLoopExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10644:1: ( rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3 )
+            // InternalOXtype.g:10645:2: rule__XForLoopExpression__Group__2__Impl rule__XForLoopExpression__Group__3
+            {
+            pushFollow(FOLLOW_15);
+            rule__XForLoopExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__2"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__2__Impl"
+    // InternalOXtype.g:10652:1: rule__XForLoopExpression__Group__2__Impl : ( ')' ) ;
+    public final void rule__XForLoopExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10656:1: ( ( ')' ) )
+            // InternalOXtype.g:10657:1: ( ')' )
+            {
+            // InternalOXtype.g:10657:1: ( ')' )
+            // InternalOXtype.g:10658:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__3"
+    // InternalOXtype.g:10667:1: rule__XForLoopExpression__Group__3 : rule__XForLoopExpression__Group__3__Impl ;
+    public final void rule__XForLoopExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10671:1: ( rule__XForLoopExpression__Group__3__Impl )
+            // InternalOXtype.g:10672:2: rule__XForLoopExpression__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__3"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group__3__Impl"
+    // InternalOXtype.g:10678:1: rule__XForLoopExpression__Group__3__Impl : ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) ;
+    public final void rule__XForLoopExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10682:1: ( ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) ) )
+            // InternalOXtype.g:10683:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) )
+            {
+            // InternalOXtype.g:10683:1: ( ( rule__XForLoopExpression__EachExpressionAssignment_3 ) )
+            // InternalOXtype.g:10684:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); 
+            }
+            // InternalOXtype.g:10685:2: ( rule__XForLoopExpression__EachExpressionAssignment_3 )
+            // InternalOXtype.g:10685:3: rule__XForLoopExpression__EachExpressionAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__EachExpressionAssignment_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionAssignment_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0__0"
+    // InternalOXtype.g:10694:1: rule__XForLoopExpression__Group_0__0 : rule__XForLoopExpression__Group_0__0__Impl ;
+    public final void rule__XForLoopExpression__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10698:1: ( rule__XForLoopExpression__Group_0__0__Impl )
+            // InternalOXtype.g:10699:2: rule__XForLoopExpression__Group_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0__0"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0__0__Impl"
+    // InternalOXtype.g:10705:1: rule__XForLoopExpression__Group_0__0__Impl : ( ( rule__XForLoopExpression__Group_0_0__0 ) ) ;
+    public final void rule__XForLoopExpression__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10709:1: ( ( ( rule__XForLoopExpression__Group_0_0__0 ) ) )
+            // InternalOXtype.g:10710:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:10710:1: ( ( rule__XForLoopExpression__Group_0_0__0 ) )
+            // InternalOXtype.g:10711:2: ( rule__XForLoopExpression__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:10712:2: ( rule__XForLoopExpression__Group_0_0__0 )
+            // InternalOXtype.g:10712:3: rule__XForLoopExpression__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__0"
+    // InternalOXtype.g:10721:1: rule__XForLoopExpression__Group_0_0__0 : rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 ;
+    public final void rule__XForLoopExpression__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10725:1: ( rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1 )
+            // InternalOXtype.g:10726:2: rule__XForLoopExpression__Group_0_0__0__Impl rule__XForLoopExpression__Group_0_0__1
+            {
+            pushFollow(FOLLOW_70);
+            rule__XForLoopExpression__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__0__Impl"
+    // InternalOXtype.g:10733:1: rule__XForLoopExpression__Group_0_0__0__Impl : ( () ) ;
+    public final void rule__XForLoopExpression__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10737:1: ( ( () ) )
+            // InternalOXtype.g:10738:1: ( () )
+            {
+            // InternalOXtype.g:10738:1: ( () )
+            // InternalOXtype.g:10739:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); 
+            }
+            // InternalOXtype.g:10740:2: ()
+            // InternalOXtype.g:10740:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__1"
+    // InternalOXtype.g:10748:1: rule__XForLoopExpression__Group_0_0__1 : rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 ;
+    public final void rule__XForLoopExpression__Group_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10752:1: ( rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2 )
+            // InternalOXtype.g:10753:2: rule__XForLoopExpression__Group_0_0__1__Impl rule__XForLoopExpression__Group_0_0__2
+            {
+            pushFollow(FOLLOW_11);
+            rule__XForLoopExpression__Group_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__1"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__1__Impl"
+    // InternalOXtype.g:10760:1: rule__XForLoopExpression__Group_0_0__1__Impl : ( 'for' ) ;
+    public final void rule__XForLoopExpression__Group_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10764:1: ( ( 'for' ) )
+            // InternalOXtype.g:10765:1: ( 'for' )
+            {
+            // InternalOXtype.g:10765:1: ( 'for' )
+            // InternalOXtype.g:10766:2: 'for'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); 
+            }
+            match(input,69,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__2"
+    // InternalOXtype.g:10775:1: rule__XForLoopExpression__Group_0_0__2 : rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 ;
+    public final void rule__XForLoopExpression__Group_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10779:1: ( rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3 )
+            // InternalOXtype.g:10780:2: rule__XForLoopExpression__Group_0_0__2__Impl rule__XForLoopExpression__Group_0_0__3
+            {
+            pushFollow(FOLLOW_32);
+            rule__XForLoopExpression__Group_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0_0__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__2"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__2__Impl"
+    // InternalOXtype.g:10787:1: rule__XForLoopExpression__Group_0_0__2__Impl : ( '(' ) ;
+    public final void rule__XForLoopExpression__Group_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10791:1: ( ( '(' ) )
+            // InternalOXtype.g:10792:1: ( '(' )
+            {
+            // InternalOXtype.g:10792:1: ( '(' )
+            // InternalOXtype.g:10793:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__3"
+    // InternalOXtype.g:10802:1: rule__XForLoopExpression__Group_0_0__3 : rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 ;
+    public final void rule__XForLoopExpression__Group_0_0__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10806:1: ( rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4 )
+            // InternalOXtype.g:10807:2: rule__XForLoopExpression__Group_0_0__3__Impl rule__XForLoopExpression__Group_0_0__4
+            {
+            pushFollow(FOLLOW_68);
+            rule__XForLoopExpression__Group_0_0__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0_0__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__3"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__3__Impl"
+    // InternalOXtype.g:10814:1: rule__XForLoopExpression__Group_0_0__3__Impl : ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) ;
+    public final void rule__XForLoopExpression__Group_0_0__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10818:1: ( ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) ) )
+            // InternalOXtype.g:10819:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) )
+            {
+            // InternalOXtype.g:10819:1: ( ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 ) )
+            // InternalOXtype.g:10820:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); 
+            }
+            // InternalOXtype.g:10821:2: ( rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 )
+            // InternalOXtype.g:10821:3: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__DeclaredParamAssignment_0_0_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamAssignment_0_0_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__3__Impl"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__4"
+    // InternalOXtype.g:10829:1: rule__XForLoopExpression__Group_0_0__4 : rule__XForLoopExpression__Group_0_0__4__Impl ;
+    public final void rule__XForLoopExpression__Group_0_0__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10833:1: ( rule__XForLoopExpression__Group_0_0__4__Impl )
+            // InternalOXtype.g:10834:2: rule__XForLoopExpression__Group_0_0__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XForLoopExpression__Group_0_0__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__4"
+
+
+    // $ANTLR start "rule__XForLoopExpression__Group_0_0__4__Impl"
+    // InternalOXtype.g:10840:1: rule__XForLoopExpression__Group_0_0__4__Impl : ( ':' ) ;
+    public final void rule__XForLoopExpression__Group_0_0__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10844:1: ( ( ':' ) )
+            // InternalOXtype.g:10845:1: ( ':' )
+            {
+            // InternalOXtype.g:10845:1: ( ':' )
+            // InternalOXtype.g:10846:2: ':'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); 
+            }
+            match(input,66,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__Group_0_0__4__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__0"
+    // InternalOXtype.g:10856:1: rule__XBasicForLoopExpression__Group__0 : rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 ;
+    public final void rule__XBasicForLoopExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10860:1: ( rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1 )
+            // InternalOXtype.g:10861:2: rule__XBasicForLoopExpression__Group__0__Impl rule__XBasicForLoopExpression__Group__1
+            {
+            pushFollow(FOLLOW_70);
+            rule__XBasicForLoopExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__0__Impl"
+    // InternalOXtype.g:10868:1: rule__XBasicForLoopExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XBasicForLoopExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10872:1: ( ( () ) )
+            // InternalOXtype.g:10873:1: ( () )
+            {
+            // InternalOXtype.g:10873:1: ( () )
+            // InternalOXtype.g:10874:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); 
+            }
+            // InternalOXtype.g:10875:2: ()
+            // InternalOXtype.g:10875:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__1"
+    // InternalOXtype.g:10883:1: rule__XBasicForLoopExpression__Group__1 : rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 ;
+    public final void rule__XBasicForLoopExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10887:1: ( rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2 )
+            // InternalOXtype.g:10888:2: rule__XBasicForLoopExpression__Group__1__Impl rule__XBasicForLoopExpression__Group__2
+            {
+            pushFollow(FOLLOW_11);
+            rule__XBasicForLoopExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__1__Impl"
+    // InternalOXtype.g:10895:1: rule__XBasicForLoopExpression__Group__1__Impl : ( 'for' ) ;
+    public final void rule__XBasicForLoopExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10899:1: ( ( 'for' ) )
+            // InternalOXtype.g:10900:1: ( 'for' )
+            {
+            // InternalOXtype.g:10900:1: ( 'for' )
+            // InternalOXtype.g:10901:2: 'for'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); 
+            }
+            match(input,69,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__2"
+    // InternalOXtype.g:10910:1: rule__XBasicForLoopExpression__Group__2 : rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 ;
+    public final void rule__XBasicForLoopExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10914:1: ( rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3 )
+            // InternalOXtype.g:10915:2: rule__XBasicForLoopExpression__Group__2__Impl rule__XBasicForLoopExpression__Group__3
+            {
+            pushFollow(FOLLOW_71);
+            rule__XBasicForLoopExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__2"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__2__Impl"
+    // InternalOXtype.g:10922:1: rule__XBasicForLoopExpression__Group__2__Impl : ( '(' ) ;
+    public final void rule__XBasicForLoopExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10926:1: ( ( '(' ) )
+            // InternalOXtype.g:10927:1: ( '(' )
+            {
+            // InternalOXtype.g:10927:1: ( '(' )
+            // InternalOXtype.g:10928:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__3"
+    // InternalOXtype.g:10937:1: rule__XBasicForLoopExpression__Group__3 : rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 ;
+    public final void rule__XBasicForLoopExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10941:1: ( rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4 )
+            // InternalOXtype.g:10942:2: rule__XBasicForLoopExpression__Group__3__Impl rule__XBasicForLoopExpression__Group__4
+            {
+            pushFollow(FOLLOW_71);
+            rule__XBasicForLoopExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__3"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__3__Impl"
+    // InternalOXtype.g:10949:1: rule__XBasicForLoopExpression__Group__3__Impl : ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) ;
+    public final void rule__XBasicForLoopExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10953:1: ( ( ( rule__XBasicForLoopExpression__Group_3__0 )? ) )
+            // InternalOXtype.g:10954:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? )
+            {
+            // InternalOXtype.g:10954:1: ( ( rule__XBasicForLoopExpression__Group_3__0 )? )
+            // InternalOXtype.g:10955:2: ( rule__XBasicForLoopExpression__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:10956:2: ( rule__XBasicForLoopExpression__Group_3__0 )?
+            int alt91=2;
+            int LA91_0 = input.LA(1);
+
+            if ( ((LA91_0>=RULE_ID && LA91_0<=RULE_STRING)||LA91_0==27||(LA91_0>=34 && LA91_0<=35)||LA91_0==40||(LA91_0>=44 && LA91_0<=50)||LA91_0==53||(LA91_0>=57 && LA91_0<=58)||LA91_0==61||LA91_0==63||LA91_0==65||(LA91_0>=69 && LA91_0<=77)||LA91_0==79||(LA91_0>=87 && LA91_0<=88)) ) {
+                alt91=1;
+            }
+            switch (alt91) {
+                case 1 :
+                    // InternalOXtype.g:10956:3: rule__XBasicForLoopExpression__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XBasicForLoopExpression__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__4"
+    // InternalOXtype.g:10964:1: rule__XBasicForLoopExpression__Group__4 : rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 ;
+    public final void rule__XBasicForLoopExpression__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10968:1: ( rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5 )
+            // InternalOXtype.g:10969:2: rule__XBasicForLoopExpression__Group__4__Impl rule__XBasicForLoopExpression__Group__5
+            {
+            pushFollow(FOLLOW_72);
+            rule__XBasicForLoopExpression__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__4"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__4__Impl"
+    // InternalOXtype.g:10976:1: rule__XBasicForLoopExpression__Group__4__Impl : ( ';' ) ;
+    public final void rule__XBasicForLoopExpression__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10980:1: ( ( ';' ) )
+            // InternalOXtype.g:10981:1: ( ';' )
+            {
+            // InternalOXtype.g:10981:1: ( ';' )
+            // InternalOXtype.g:10982:2: ';'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); 
+            }
+            match(input,51,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__5"
+    // InternalOXtype.g:10991:1: rule__XBasicForLoopExpression__Group__5 : rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 ;
+    public final void rule__XBasicForLoopExpression__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:10995:1: ( rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6 )
+            // InternalOXtype.g:10996:2: rule__XBasicForLoopExpression__Group__5__Impl rule__XBasicForLoopExpression__Group__6
+            {
+            pushFollow(FOLLOW_72);
+            rule__XBasicForLoopExpression__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__6();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__5"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__5__Impl"
+    // InternalOXtype.g:11003:1: rule__XBasicForLoopExpression__Group__5__Impl : ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) ;
+    public final void rule__XBasicForLoopExpression__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11007:1: ( ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? ) )
+            // InternalOXtype.g:11008:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? )
+            {
+            // InternalOXtype.g:11008:1: ( ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )? )
+            // InternalOXtype.g:11009:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); 
+            }
+            // InternalOXtype.g:11010:2: ( rule__XBasicForLoopExpression__ExpressionAssignment_5 )?
+            int alt92=2;
+            int LA92_0 = input.LA(1);
+
+            if ( ((LA92_0>=RULE_ID && LA92_0<=RULE_STRING)||LA92_0==27||(LA92_0>=34 && LA92_0<=35)||LA92_0==40||(LA92_0>=45 && LA92_0<=50)||LA92_0==53||(LA92_0>=57 && LA92_0<=58)||LA92_0==61||LA92_0==63||LA92_0==65||(LA92_0>=69 && LA92_0<=77)||LA92_0==79||LA92_0==88) ) {
+                alt92=1;
+            }
+            switch (alt92) {
+                case 1 :
+                    // InternalOXtype.g:11010:3: rule__XBasicForLoopExpression__ExpressionAssignment_5
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XBasicForLoopExpression__ExpressionAssignment_5();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionAssignment_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__6"
+    // InternalOXtype.g:11018:1: rule__XBasicForLoopExpression__Group__6 : rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 ;
+    public final void rule__XBasicForLoopExpression__Group__6() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11022:1: ( rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7 )
+            // InternalOXtype.g:11023:2: rule__XBasicForLoopExpression__Group__6__Impl rule__XBasicForLoopExpression__Group__7
+            {
+            pushFollow(FOLLOW_12);
+            rule__XBasicForLoopExpression__Group__6__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__7();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__6"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__6__Impl"
+    // InternalOXtype.g:11030:1: rule__XBasicForLoopExpression__Group__6__Impl : ( ';' ) ;
+    public final void rule__XBasicForLoopExpression__Group__6__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11034:1: ( ( ';' ) )
+            // InternalOXtype.g:11035:1: ( ';' )
+            {
+            // InternalOXtype.g:11035:1: ( ';' )
+            // InternalOXtype.g:11036:2: ';'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); 
+            }
+            match(input,51,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__6__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__7"
+    // InternalOXtype.g:11045:1: rule__XBasicForLoopExpression__Group__7 : rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 ;
+    public final void rule__XBasicForLoopExpression__Group__7() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11049:1: ( rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8 )
+            // InternalOXtype.g:11050:2: rule__XBasicForLoopExpression__Group__7__Impl rule__XBasicForLoopExpression__Group__8
+            {
+            pushFollow(FOLLOW_12);
+            rule__XBasicForLoopExpression__Group__7__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__8();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__7"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__7__Impl"
+    // InternalOXtype.g:11057:1: rule__XBasicForLoopExpression__Group__7__Impl : ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) ;
+    public final void rule__XBasicForLoopExpression__Group__7__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11061:1: ( ( ( rule__XBasicForLoopExpression__Group_7__0 )? ) )
+            // InternalOXtype.g:11062:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? )
+            {
+            // InternalOXtype.g:11062:1: ( ( rule__XBasicForLoopExpression__Group_7__0 )? )
+            // InternalOXtype.g:11063:2: ( rule__XBasicForLoopExpression__Group_7__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); 
+            }
+            // InternalOXtype.g:11064:2: ( rule__XBasicForLoopExpression__Group_7__0 )?
+            int alt93=2;
+            int LA93_0 = input.LA(1);
+
+            if ( ((LA93_0>=RULE_ID && LA93_0<=RULE_STRING)||LA93_0==27||(LA93_0>=34 && LA93_0<=35)||LA93_0==40||(LA93_0>=45 && LA93_0<=50)||LA93_0==53||(LA93_0>=57 && LA93_0<=58)||LA93_0==61||LA93_0==63||LA93_0==65||(LA93_0>=69 && LA93_0<=77)||LA93_0==79||LA93_0==88) ) {
+                alt93=1;
+            }
+            switch (alt93) {
+                case 1 :
+                    // InternalOXtype.g:11064:3: rule__XBasicForLoopExpression__Group_7__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XBasicForLoopExpression__Group_7__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__7__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__8"
+    // InternalOXtype.g:11072:1: rule__XBasicForLoopExpression__Group__8 : rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 ;
+    public final void rule__XBasicForLoopExpression__Group__8() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11076:1: ( rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9 )
+            // InternalOXtype.g:11077:2: rule__XBasicForLoopExpression__Group__8__Impl rule__XBasicForLoopExpression__Group__9
+            {
+            pushFollow(FOLLOW_15);
+            rule__XBasicForLoopExpression__Group__8__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__9();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__8"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__8__Impl"
+    // InternalOXtype.g:11084:1: rule__XBasicForLoopExpression__Group__8__Impl : ( ')' ) ;
+    public final void rule__XBasicForLoopExpression__Group__8__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11088:1: ( ( ')' ) )
+            // InternalOXtype.g:11089:1: ( ')' )
+            {
+            // InternalOXtype.g:11089:1: ( ')' )
+            // InternalOXtype.g:11090:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__8__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__9"
+    // InternalOXtype.g:11099:1: rule__XBasicForLoopExpression__Group__9 : rule__XBasicForLoopExpression__Group__9__Impl ;
+    public final void rule__XBasicForLoopExpression__Group__9() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11103:1: ( rule__XBasicForLoopExpression__Group__9__Impl )
+            // InternalOXtype.g:11104:2: rule__XBasicForLoopExpression__Group__9__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group__9__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__9"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group__9__Impl"
+    // InternalOXtype.g:11110:1: rule__XBasicForLoopExpression__Group__9__Impl : ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) ;
+    public final void rule__XBasicForLoopExpression__Group__9__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11114:1: ( ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) ) )
+            // InternalOXtype.g:11115:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) )
+            {
+            // InternalOXtype.g:11115:1: ( ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 ) )
+            // InternalOXtype.g:11116:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); 
+            }
+            // InternalOXtype.g:11117:2: ( rule__XBasicForLoopExpression__EachExpressionAssignment_9 )
+            // InternalOXtype.g:11117:3: rule__XBasicForLoopExpression__EachExpressionAssignment_9
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__EachExpressionAssignment_9();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionAssignment_9()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group__9__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0"
+    // InternalOXtype.g:11126:1: rule__XBasicForLoopExpression__Group_3__0 : rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 ;
+    public final void rule__XBasicForLoopExpression__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11130:1: ( rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1 )
+            // InternalOXtype.g:11131:2: rule__XBasicForLoopExpression__Group_3__0__Impl rule__XBasicForLoopExpression__Group_3__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XBasicForLoopExpression__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3__0__Impl"
+    // InternalOXtype.g:11138:1: rule__XBasicForLoopExpression__Group_3__0__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) ;
+    public final void rule__XBasicForLoopExpression__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11142:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) ) )
+            // InternalOXtype.g:11143:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) )
+            {
+            // InternalOXtype.g:11143:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 ) )
+            // InternalOXtype.g:11144:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); 
+            }
+            // InternalOXtype.g:11145:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 )
+            // InternalOXtype.g:11145:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1"
+    // InternalOXtype.g:11153:1: rule__XBasicForLoopExpression__Group_3__1 : rule__XBasicForLoopExpression__Group_3__1__Impl ;
+    public final void rule__XBasicForLoopExpression__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11157:1: ( rule__XBasicForLoopExpression__Group_3__1__Impl )
+            // InternalOXtype.g:11158:2: rule__XBasicForLoopExpression__Group_3__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3__1__Impl"
+    // InternalOXtype.g:11164:1: rule__XBasicForLoopExpression__Group_3__1__Impl : ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) ;
+    public final void rule__XBasicForLoopExpression__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11168:1: ( ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* ) )
+            // InternalOXtype.g:11169:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* )
+            {
+            // InternalOXtype.g:11169:1: ( ( rule__XBasicForLoopExpression__Group_3_1__0 )* )
+            // InternalOXtype.g:11170:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); 
+            }
+            // InternalOXtype.g:11171:2: ( rule__XBasicForLoopExpression__Group_3_1__0 )*
+            loop94:
+            do {
+                int alt94=2;
+                int LA94_0 = input.LA(1);
+
+                if ( (LA94_0==55) ) {
+                    alt94=1;
+                }
+
+
+                switch (alt94) {
+            	case 1 :
+            	    // InternalOXtype.g:11171:3: rule__XBasicForLoopExpression__Group_3_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XBasicForLoopExpression__Group_3_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop94;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0"
+    // InternalOXtype.g:11180:1: rule__XBasicForLoopExpression__Group_3_1__0 : rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 ;
+    public final void rule__XBasicForLoopExpression__Group_3_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11184:1: ( rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1 )
+            // InternalOXtype.g:11185:2: rule__XBasicForLoopExpression__Group_3_1__0__Impl rule__XBasicForLoopExpression__Group_3_1__1
+            {
+            pushFollow(FOLLOW_73);
+            rule__XBasicForLoopExpression__Group_3_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_3_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__0__Impl"
+    // InternalOXtype.g:11192:1: rule__XBasicForLoopExpression__Group_3_1__0__Impl : ( ',' ) ;
+    public final void rule__XBasicForLoopExpression__Group_3_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11196:1: ( ( ',' ) )
+            // InternalOXtype.g:11197:1: ( ',' )
+            {
+            // InternalOXtype.g:11197:1: ( ',' )
+            // InternalOXtype.g:11198:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__0__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1"
+    // InternalOXtype.g:11207:1: rule__XBasicForLoopExpression__Group_3_1__1 : rule__XBasicForLoopExpression__Group_3_1__1__Impl ;
+    public final void rule__XBasicForLoopExpression__Group_3_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11211:1: ( rule__XBasicForLoopExpression__Group_3_1__1__Impl )
+            // InternalOXtype.g:11212:2: rule__XBasicForLoopExpression__Group_3_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_3_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_3_1__1__Impl"
+    // InternalOXtype.g:11218:1: rule__XBasicForLoopExpression__Group_3_1__1__Impl : ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) ;
+    public final void rule__XBasicForLoopExpression__Group_3_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11222:1: ( ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) ) )
+            // InternalOXtype.g:11223:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) )
+            {
+            // InternalOXtype.g:11223:1: ( ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 ) )
+            // InternalOXtype.g:11224:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); 
+            }
+            // InternalOXtype.g:11225:2: ( rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 )
+            // InternalOXtype.g:11225:3: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsAssignment_3_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_3_1__1__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0"
+    // InternalOXtype.g:11234:1: rule__XBasicForLoopExpression__Group_7__0 : rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 ;
+    public final void rule__XBasicForLoopExpression__Group_7__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11238:1: ( rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1 )
+            // InternalOXtype.g:11239:2: rule__XBasicForLoopExpression__Group_7__0__Impl rule__XBasicForLoopExpression__Group_7__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XBasicForLoopExpression__Group_7__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_7__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7__0__Impl"
+    // InternalOXtype.g:11246:1: rule__XBasicForLoopExpression__Group_7__0__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) ;
+    public final void rule__XBasicForLoopExpression__Group_7__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11250:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) ) )
+            // InternalOXtype.g:11251:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) )
+            {
+            // InternalOXtype.g:11251:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 ) )
+            // InternalOXtype.g:11252:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); 
+            }
+            // InternalOXtype.g:11253:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 )
+            // InternalOXtype.g:11253:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7__0__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1"
+    // InternalOXtype.g:11261:1: rule__XBasicForLoopExpression__Group_7__1 : rule__XBasicForLoopExpression__Group_7__1__Impl ;
+    public final void rule__XBasicForLoopExpression__Group_7__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11265:1: ( rule__XBasicForLoopExpression__Group_7__1__Impl )
+            // InternalOXtype.g:11266:2: rule__XBasicForLoopExpression__Group_7__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_7__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7__1__Impl"
+    // InternalOXtype.g:11272:1: rule__XBasicForLoopExpression__Group_7__1__Impl : ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) ;
+    public final void rule__XBasicForLoopExpression__Group_7__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11276:1: ( ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* ) )
+            // InternalOXtype.g:11277:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* )
+            {
+            // InternalOXtype.g:11277:1: ( ( rule__XBasicForLoopExpression__Group_7_1__0 )* )
+            // InternalOXtype.g:11278:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); 
+            }
+            // InternalOXtype.g:11279:2: ( rule__XBasicForLoopExpression__Group_7_1__0 )*
+            loop95:
+            do {
+                int alt95=2;
+                int LA95_0 = input.LA(1);
+
+                if ( (LA95_0==55) ) {
+                    alt95=1;
+                }
+
+
+                switch (alt95) {
+            	case 1 :
+            	    // InternalOXtype.g:11279:3: rule__XBasicForLoopExpression__Group_7_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XBasicForLoopExpression__Group_7_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop95;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup_7_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7__1__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0"
+    // InternalOXtype.g:11288:1: rule__XBasicForLoopExpression__Group_7_1__0 : rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 ;
+    public final void rule__XBasicForLoopExpression__Group_7_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11292:1: ( rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1 )
+            // InternalOXtype.g:11293:2: rule__XBasicForLoopExpression__Group_7_1__0__Impl rule__XBasicForLoopExpression__Group_7_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XBasicForLoopExpression__Group_7_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_7_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__0__Impl"
+    // InternalOXtype.g:11300:1: rule__XBasicForLoopExpression__Group_7_1__0__Impl : ( ',' ) ;
+    public final void rule__XBasicForLoopExpression__Group_7_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11304:1: ( ( ',' ) )
+            // InternalOXtype.g:11305:1: ( ',' )
+            {
+            // InternalOXtype.g:11305:1: ( ',' )
+            // InternalOXtype.g:11306:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__0__Impl"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1"
+    // InternalOXtype.g:11315:1: rule__XBasicForLoopExpression__Group_7_1__1 : rule__XBasicForLoopExpression__Group_7_1__1__Impl ;
+    public final void rule__XBasicForLoopExpression__Group_7_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11319:1: ( rule__XBasicForLoopExpression__Group_7_1__1__Impl )
+            // InternalOXtype.g:11320:2: rule__XBasicForLoopExpression__Group_7_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__Group_7_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__Group_7_1__1__Impl"
+    // InternalOXtype.g:11326:1: rule__XBasicForLoopExpression__Group_7_1__1__Impl : ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) ;
+    public final void rule__XBasicForLoopExpression__Group_7_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11330:1: ( ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) ) )
+            // InternalOXtype.g:11331:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) )
+            {
+            // InternalOXtype.g:11331:1: ( ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 ) )
+            // InternalOXtype.g:11332:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); 
+            }
+            // InternalOXtype.g:11333:2: ( rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 )
+            // InternalOXtype.g:11333:3: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsAssignment_7_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__Group_7_1__1__Impl"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__0"
+    // InternalOXtype.g:11342:1: rule__XWhileExpression__Group__0 : rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 ;
+    public final void rule__XWhileExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11346:1: ( rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1 )
+            // InternalOXtype.g:11347:2: rule__XWhileExpression__Group__0__Impl rule__XWhileExpression__Group__1
+            {
+            pushFollow(FOLLOW_74);
+            rule__XWhileExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__0"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__0__Impl"
+    // InternalOXtype.g:11354:1: rule__XWhileExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XWhileExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11358:1: ( ( () ) )
+            // InternalOXtype.g:11359:1: ( () )
+            {
+            // InternalOXtype.g:11359:1: ( () )
+            // InternalOXtype.g:11360:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); 
+            }
+            // InternalOXtype.g:11361:2: ()
+            // InternalOXtype.g:11361:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__1"
+    // InternalOXtype.g:11369:1: rule__XWhileExpression__Group__1 : rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 ;
+    public final void rule__XWhileExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11373:1: ( rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2 )
+            // InternalOXtype.g:11374:2: rule__XWhileExpression__Group__1__Impl rule__XWhileExpression__Group__2
+            {
+            pushFollow(FOLLOW_11);
+            rule__XWhileExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__1"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__1__Impl"
+    // InternalOXtype.g:11381:1: rule__XWhileExpression__Group__1__Impl : ( 'while' ) ;
+    public final void rule__XWhileExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11385:1: ( ( 'while' ) )
+            // InternalOXtype.g:11386:1: ( 'while' )
+            {
+            // InternalOXtype.g:11386:1: ( 'while' )
+            // InternalOXtype.g:11387:2: 'while'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); 
+            }
+            match(input,70,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__2"
+    // InternalOXtype.g:11396:1: rule__XWhileExpression__Group__2 : rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 ;
+    public final void rule__XWhileExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11400:1: ( rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3 )
+            // InternalOXtype.g:11401:2: rule__XWhileExpression__Group__2__Impl rule__XWhileExpression__Group__3
+            {
+            pushFollow(FOLLOW_15);
+            rule__XWhileExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__2"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__2__Impl"
+    // InternalOXtype.g:11408:1: rule__XWhileExpression__Group__2__Impl : ( '(' ) ;
+    public final void rule__XWhileExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11412:1: ( ( '(' ) )
+            // InternalOXtype.g:11413:1: ( '(' )
+            {
+            // InternalOXtype.g:11413:1: ( '(' )
+            // InternalOXtype.g:11414:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__3"
+    // InternalOXtype.g:11423:1: rule__XWhileExpression__Group__3 : rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 ;
+    public final void rule__XWhileExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11427:1: ( rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4 )
+            // InternalOXtype.g:11428:2: rule__XWhileExpression__Group__3__Impl rule__XWhileExpression__Group__4
+            {
+            pushFollow(FOLLOW_61);
+            rule__XWhileExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__3"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__3__Impl"
+    // InternalOXtype.g:11435:1: rule__XWhileExpression__Group__3__Impl : ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) ;
+    public final void rule__XWhileExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11439:1: ( ( ( rule__XWhileExpression__PredicateAssignment_3 ) ) )
+            // InternalOXtype.g:11440:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) )
+            {
+            // InternalOXtype.g:11440:1: ( ( rule__XWhileExpression__PredicateAssignment_3 ) )
+            // InternalOXtype.g:11441:2: ( rule__XWhileExpression__PredicateAssignment_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); 
+            }
+            // InternalOXtype.g:11442:2: ( rule__XWhileExpression__PredicateAssignment_3 )
+            // InternalOXtype.g:11442:3: rule__XWhileExpression__PredicateAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__PredicateAssignment_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getPredicateAssignment_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__4"
+    // InternalOXtype.g:11450:1: rule__XWhileExpression__Group__4 : rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 ;
+    public final void rule__XWhileExpression__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11454:1: ( rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5 )
+            // InternalOXtype.g:11455:2: rule__XWhileExpression__Group__4__Impl rule__XWhileExpression__Group__5
+            {
+            pushFollow(FOLLOW_15);
+            rule__XWhileExpression__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__4"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__4__Impl"
+    // InternalOXtype.g:11462:1: rule__XWhileExpression__Group__4__Impl : ( ')' ) ;
+    public final void rule__XWhileExpression__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11466:1: ( ( ')' ) )
+            // InternalOXtype.g:11467:1: ( ')' )
+            {
+            // InternalOXtype.g:11467:1: ( ')' )
+            // InternalOXtype.g:11468:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__5"
+    // InternalOXtype.g:11477:1: rule__XWhileExpression__Group__5 : rule__XWhileExpression__Group__5__Impl ;
+    public final void rule__XWhileExpression__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11481:1: ( rule__XWhileExpression__Group__5__Impl )
+            // InternalOXtype.g:11482:2: rule__XWhileExpression__Group__5__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__5"
+
+
+    // $ANTLR start "rule__XWhileExpression__Group__5__Impl"
+    // InternalOXtype.g:11488:1: rule__XWhileExpression__Group__5__Impl : ( ( rule__XWhileExpression__BodyAssignment_5 ) ) ;
+    public final void rule__XWhileExpression__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11492:1: ( ( ( rule__XWhileExpression__BodyAssignment_5 ) ) )
+            // InternalOXtype.g:11493:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) )
+            {
+            // InternalOXtype.g:11493:1: ( ( rule__XWhileExpression__BodyAssignment_5 ) )
+            // InternalOXtype.g:11494:2: ( rule__XWhileExpression__BodyAssignment_5 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); 
+            }
+            // InternalOXtype.g:11495:2: ( rule__XWhileExpression__BodyAssignment_5 )
+            // InternalOXtype.g:11495:3: rule__XWhileExpression__BodyAssignment_5
+            {
+            pushFollow(FOLLOW_2);
+            rule__XWhileExpression__BodyAssignment_5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getBodyAssignment_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__0"
+    // InternalOXtype.g:11504:1: rule__XDoWhileExpression__Group__0 : rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 ;
+    public final void rule__XDoWhileExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11508:1: ( rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1 )
+            // InternalOXtype.g:11509:2: rule__XDoWhileExpression__Group__0__Impl rule__XDoWhileExpression__Group__1
+            {
+            pushFollow(FOLLOW_75);
+            rule__XDoWhileExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__0"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__0__Impl"
+    // InternalOXtype.g:11516:1: rule__XDoWhileExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XDoWhileExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11520:1: ( ( () ) )
+            // InternalOXtype.g:11521:1: ( () )
+            {
+            // InternalOXtype.g:11521:1: ( () )
+            // InternalOXtype.g:11522:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); 
+            }
+            // InternalOXtype.g:11523:2: ()
+            // InternalOXtype.g:11523:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__1"
+    // InternalOXtype.g:11531:1: rule__XDoWhileExpression__Group__1 : rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 ;
+    public final void rule__XDoWhileExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11535:1: ( rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2 )
+            // InternalOXtype.g:11536:2: rule__XDoWhileExpression__Group__1__Impl rule__XDoWhileExpression__Group__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__XDoWhileExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__1"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__1__Impl"
+    // InternalOXtype.g:11543:1: rule__XDoWhileExpression__Group__1__Impl : ( 'do' ) ;
+    public final void rule__XDoWhileExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11547:1: ( ( 'do' ) )
+            // InternalOXtype.g:11548:1: ( 'do' )
+            {
+            // InternalOXtype.g:11548:1: ( 'do' )
+            // InternalOXtype.g:11549:2: 'do'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); 
+            }
+            match(input,71,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__2"
+    // InternalOXtype.g:11558:1: rule__XDoWhileExpression__Group__2 : rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 ;
+    public final void rule__XDoWhileExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11562:1: ( rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3 )
+            // InternalOXtype.g:11563:2: rule__XDoWhileExpression__Group__2__Impl rule__XDoWhileExpression__Group__3
+            {
+            pushFollow(FOLLOW_74);
+            rule__XDoWhileExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__2"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__2__Impl"
+    // InternalOXtype.g:11570:1: rule__XDoWhileExpression__Group__2__Impl : ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) ;
+    public final void rule__XDoWhileExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11574:1: ( ( ( rule__XDoWhileExpression__BodyAssignment_2 ) ) )
+            // InternalOXtype.g:11575:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) )
+            {
+            // InternalOXtype.g:11575:1: ( ( rule__XDoWhileExpression__BodyAssignment_2 ) )
+            // InternalOXtype.g:11576:2: ( rule__XDoWhileExpression__BodyAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); 
+            }
+            // InternalOXtype.g:11577:2: ( rule__XDoWhileExpression__BodyAssignment_2 )
+            // InternalOXtype.g:11577:3: rule__XDoWhileExpression__BodyAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__BodyAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getBodyAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__3"
+    // InternalOXtype.g:11585:1: rule__XDoWhileExpression__Group__3 : rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 ;
+    public final void rule__XDoWhileExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11589:1: ( rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4 )
+            // InternalOXtype.g:11590:2: rule__XDoWhileExpression__Group__3__Impl rule__XDoWhileExpression__Group__4
+            {
+            pushFollow(FOLLOW_11);
+            rule__XDoWhileExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__3"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__3__Impl"
+    // InternalOXtype.g:11597:1: rule__XDoWhileExpression__Group__3__Impl : ( 'while' ) ;
+    public final void rule__XDoWhileExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11601:1: ( ( 'while' ) )
+            // InternalOXtype.g:11602:1: ( 'while' )
+            {
+            // InternalOXtype.g:11602:1: ( 'while' )
+            // InternalOXtype.g:11603:2: 'while'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); 
+            }
+            match(input,70,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__4"
+    // InternalOXtype.g:11612:1: rule__XDoWhileExpression__Group__4 : rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 ;
+    public final void rule__XDoWhileExpression__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11616:1: ( rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5 )
+            // InternalOXtype.g:11617:2: rule__XDoWhileExpression__Group__4__Impl rule__XDoWhileExpression__Group__5
+            {
+            pushFollow(FOLLOW_15);
+            rule__XDoWhileExpression__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__4"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__4__Impl"
+    // InternalOXtype.g:11624:1: rule__XDoWhileExpression__Group__4__Impl : ( '(' ) ;
+    public final void rule__XDoWhileExpression__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11628:1: ( ( '(' ) )
+            // InternalOXtype.g:11629:1: ( '(' )
+            {
+            // InternalOXtype.g:11629:1: ( '(' )
+            // InternalOXtype.g:11630:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__5"
+    // InternalOXtype.g:11639:1: rule__XDoWhileExpression__Group__5 : rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 ;
+    public final void rule__XDoWhileExpression__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11643:1: ( rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6 )
+            // InternalOXtype.g:11644:2: rule__XDoWhileExpression__Group__5__Impl rule__XDoWhileExpression__Group__6
+            {
+            pushFollow(FOLLOW_61);
+            rule__XDoWhileExpression__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__6();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__5"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__5__Impl"
+    // InternalOXtype.g:11651:1: rule__XDoWhileExpression__Group__5__Impl : ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) ;
+    public final void rule__XDoWhileExpression__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11655:1: ( ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) ) )
+            // InternalOXtype.g:11656:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) )
+            {
+            // InternalOXtype.g:11656:1: ( ( rule__XDoWhileExpression__PredicateAssignment_5 ) )
+            // InternalOXtype.g:11657:2: ( rule__XDoWhileExpression__PredicateAssignment_5 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); 
+            }
+            // InternalOXtype.g:11658:2: ( rule__XDoWhileExpression__PredicateAssignment_5 )
+            // InternalOXtype.g:11658:3: rule__XDoWhileExpression__PredicateAssignment_5
+            {
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__PredicateAssignment_5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getPredicateAssignment_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__6"
+    // InternalOXtype.g:11666:1: rule__XDoWhileExpression__Group__6 : rule__XDoWhileExpression__Group__6__Impl ;
+    public final void rule__XDoWhileExpression__Group__6() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11670:1: ( rule__XDoWhileExpression__Group__6__Impl )
+            // InternalOXtype.g:11671:2: rule__XDoWhileExpression__Group__6__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XDoWhileExpression__Group__6__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__6"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__Group__6__Impl"
+    // InternalOXtype.g:11677:1: rule__XDoWhileExpression__Group__6__Impl : ( ')' ) ;
+    public final void rule__XDoWhileExpression__Group__6__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11681:1: ( ( ')' ) )
+            // InternalOXtype.g:11682:1: ( ')' )
+            {
+            // InternalOXtype.g:11682:1: ( ')' )
+            // InternalOXtype.g:11683:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__Group__6__Impl"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__0"
+    // InternalOXtype.g:11693:1: rule__XBlockExpression__Group__0 : rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 ;
+    public final void rule__XBlockExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11697:1: ( rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1 )
+            // InternalOXtype.g:11698:2: rule__XBlockExpression__Group__0__Impl rule__XBlockExpression__Group__1
+            {
+            pushFollow(FOLLOW_55);
+            rule__XBlockExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__0"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__0__Impl"
+    // InternalOXtype.g:11705:1: rule__XBlockExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XBlockExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11709:1: ( ( () ) )
+            // InternalOXtype.g:11710:1: ( () )
+            {
+            // InternalOXtype.g:11710:1: ( () )
+            // InternalOXtype.g:11711:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); 
+            }
+            // InternalOXtype.g:11712:2: ()
+            // InternalOXtype.g:11712:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__1"
+    // InternalOXtype.g:11720:1: rule__XBlockExpression__Group__1 : rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 ;
+    public final void rule__XBlockExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11724:1: ( rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2 )
+            // InternalOXtype.g:11725:2: rule__XBlockExpression__Group__1__Impl rule__XBlockExpression__Group__2
+            {
+            pushFollow(FOLLOW_76);
+            rule__XBlockExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__1"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__1__Impl"
+    // InternalOXtype.g:11732:1: rule__XBlockExpression__Group__1__Impl : ( '{' ) ;
+    public final void rule__XBlockExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11736:1: ( ( '{' ) )
+            // InternalOXtype.g:11737:1: ( '{' )
+            {
+            // InternalOXtype.g:11737:1: ( '{' )
+            // InternalOXtype.g:11738:2: '{'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); 
+            }
+            match(input,61,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__2"
+    // InternalOXtype.g:11747:1: rule__XBlockExpression__Group__2 : rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 ;
+    public final void rule__XBlockExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11751:1: ( rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3 )
+            // InternalOXtype.g:11752:2: rule__XBlockExpression__Group__2__Impl rule__XBlockExpression__Group__3
+            {
+            pushFollow(FOLLOW_76);
+            rule__XBlockExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__2"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__2__Impl"
+    // InternalOXtype.g:11759:1: rule__XBlockExpression__Group__2__Impl : ( ( rule__XBlockExpression__Group_2__0 )* ) ;
+    public final void rule__XBlockExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11763:1: ( ( ( rule__XBlockExpression__Group_2__0 )* ) )
+            // InternalOXtype.g:11764:1: ( ( rule__XBlockExpression__Group_2__0 )* )
+            {
+            // InternalOXtype.g:11764:1: ( ( rule__XBlockExpression__Group_2__0 )* )
+            // InternalOXtype.g:11765:2: ( rule__XBlockExpression__Group_2__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getGroup_2()); 
+            }
+            // InternalOXtype.g:11766:2: ( rule__XBlockExpression__Group_2__0 )*
+            loop96:
+            do {
+                int alt96=2;
+                int LA96_0 = input.LA(1);
+
+                if ( ((LA96_0>=RULE_ID && LA96_0<=RULE_STRING)||LA96_0==27||(LA96_0>=34 && LA96_0<=35)||LA96_0==40||(LA96_0>=44 && LA96_0<=50)||LA96_0==53||(LA96_0>=57 && LA96_0<=58)||LA96_0==61||LA96_0==63||LA96_0==65||(LA96_0>=69 && LA96_0<=77)||LA96_0==79||(LA96_0>=87 && LA96_0<=88)) ) {
+                    alt96=1;
+                }
+
+
+                switch (alt96) {
+            	case 1 :
+            	    // InternalOXtype.g:11766:3: rule__XBlockExpression__Group_2__0
+            	    {
+            	    pushFollow(FOLLOW_60);
+            	    rule__XBlockExpression__Group_2__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop96;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getGroup_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__3"
+    // InternalOXtype.g:11774:1: rule__XBlockExpression__Group__3 : rule__XBlockExpression__Group__3__Impl ;
+    public final void rule__XBlockExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11778:1: ( rule__XBlockExpression__Group__3__Impl )
+            // InternalOXtype.g:11779:2: rule__XBlockExpression__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__3"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group__3__Impl"
+    // InternalOXtype.g:11785:1: rule__XBlockExpression__Group__3__Impl : ( '}' ) ;
+    public final void rule__XBlockExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11789:1: ( ( '}' ) )
+            // InternalOXtype.g:11790:1: ( '}' )
+            {
+            // InternalOXtype.g:11790:1: ( '}' )
+            // InternalOXtype.g:11791:2: '}'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); 
+            }
+            match(input,62,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group_2__0"
+    // InternalOXtype.g:11801:1: rule__XBlockExpression__Group_2__0 : rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 ;
+    public final void rule__XBlockExpression__Group_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11805:1: ( rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1 )
+            // InternalOXtype.g:11806:2: rule__XBlockExpression__Group_2__0__Impl rule__XBlockExpression__Group_2__1
+            {
+            pushFollow(FOLLOW_6);
+            rule__XBlockExpression__Group_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group_2__0"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group_2__0__Impl"
+    // InternalOXtype.g:11813:1: rule__XBlockExpression__Group_2__0__Impl : ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) ;
+    public final void rule__XBlockExpression__Group_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11817:1: ( ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) ) )
+            // InternalOXtype.g:11818:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) )
+            {
+            // InternalOXtype.g:11818:1: ( ( rule__XBlockExpression__ExpressionsAssignment_2_0 ) )
+            // InternalOXtype.g:11819:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); 
+            }
+            // InternalOXtype.g:11820:2: ( rule__XBlockExpression__ExpressionsAssignment_2_0 )
+            // InternalOXtype.g:11820:3: rule__XBlockExpression__ExpressionsAssignment_2_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__ExpressionsAssignment_2_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getExpressionsAssignment_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group_2__0__Impl"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group_2__1"
+    // InternalOXtype.g:11828:1: rule__XBlockExpression__Group_2__1 : rule__XBlockExpression__Group_2__1__Impl ;
+    public final void rule__XBlockExpression__Group_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11832:1: ( rule__XBlockExpression__Group_2__1__Impl )
+            // InternalOXtype.g:11833:2: rule__XBlockExpression__Group_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBlockExpression__Group_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group_2__1"
+
+
+    // $ANTLR start "rule__XBlockExpression__Group_2__1__Impl"
+    // InternalOXtype.g:11839:1: rule__XBlockExpression__Group_2__1__Impl : ( ( ';' )? ) ;
+    public final void rule__XBlockExpression__Group_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11843:1: ( ( ( ';' )? ) )
+            // InternalOXtype.g:11844:1: ( ( ';' )? )
+            {
+            // InternalOXtype.g:11844:1: ( ( ';' )? )
+            // InternalOXtype.g:11845:2: ( ';' )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); 
+            }
+            // InternalOXtype.g:11846:2: ( ';' )?
+            int alt97=2;
+            int LA97_0 = input.LA(1);
+
+            if ( (LA97_0==51) ) {
+                alt97=1;
+            }
+            switch (alt97) {
+                case 1 :
+                    // InternalOXtype.g:11846:3: ';'
+                    {
+                    match(input,51,FOLLOW_2); if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__Group_2__1__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__0"
+    // InternalOXtype.g:11855:1: rule__XVariableDeclaration__Group__0 : rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 ;
+    public final void rule__XVariableDeclaration__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11859:1: ( rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1 )
+            // InternalOXtype.g:11860:2: rule__XVariableDeclaration__Group__0__Impl rule__XVariableDeclaration__Group__1
+            {
+            pushFollow(FOLLOW_77);
+            rule__XVariableDeclaration__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__0__Impl"
+    // InternalOXtype.g:11867:1: rule__XVariableDeclaration__Group__0__Impl : ( () ) ;
+    public final void rule__XVariableDeclaration__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11871:1: ( ( () ) )
+            // InternalOXtype.g:11872:1: ( () )
+            {
+            // InternalOXtype.g:11872:1: ( () )
+            // InternalOXtype.g:11873:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); 
+            }
+            // InternalOXtype.g:11874:2: ()
+            // InternalOXtype.g:11874:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__1"
+    // InternalOXtype.g:11882:1: rule__XVariableDeclaration__Group__1 : rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 ;
+    public final void rule__XVariableDeclaration__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11886:1: ( rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2 )
+            // InternalOXtype.g:11887:2: rule__XVariableDeclaration__Group__1__Impl rule__XVariableDeclaration__Group__2
+            {
+            pushFollow(FOLLOW_32);
+            rule__XVariableDeclaration__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__1"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__1__Impl"
+    // InternalOXtype.g:11894:1: rule__XVariableDeclaration__Group__1__Impl : ( ( rule__XVariableDeclaration__Alternatives_1 ) ) ;
+    public final void rule__XVariableDeclaration__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11898:1: ( ( ( rule__XVariableDeclaration__Alternatives_1 ) ) )
+            // InternalOXtype.g:11899:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) )
+            {
+            // InternalOXtype.g:11899:1: ( ( rule__XVariableDeclaration__Alternatives_1 ) )
+            // InternalOXtype.g:11900:2: ( rule__XVariableDeclaration__Alternatives_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); 
+            }
+            // InternalOXtype.g:11901:2: ( rule__XVariableDeclaration__Alternatives_1 )
+            // InternalOXtype.g:11901:3: rule__XVariableDeclaration__Alternatives_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Alternatives_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__2"
+    // InternalOXtype.g:11909:1: rule__XVariableDeclaration__Group__2 : rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 ;
+    public final void rule__XVariableDeclaration__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11913:1: ( rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3 )
+            // InternalOXtype.g:11914:2: rule__XVariableDeclaration__Group__2__Impl rule__XVariableDeclaration__Group__3
+            {
+            pushFollow(FOLLOW_16);
+            rule__XVariableDeclaration__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__2"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__2__Impl"
+    // InternalOXtype.g:11921:1: rule__XVariableDeclaration__Group__2__Impl : ( ( rule__XVariableDeclaration__Alternatives_2 ) ) ;
+    public final void rule__XVariableDeclaration__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11925:1: ( ( ( rule__XVariableDeclaration__Alternatives_2 ) ) )
+            // InternalOXtype.g:11926:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) )
+            {
+            // InternalOXtype.g:11926:1: ( ( rule__XVariableDeclaration__Alternatives_2 ) )
+            // InternalOXtype.g:11927:2: ( rule__XVariableDeclaration__Alternatives_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); 
+            }
+            // InternalOXtype.g:11928:2: ( rule__XVariableDeclaration__Alternatives_2 )
+            // InternalOXtype.g:11928:3: rule__XVariableDeclaration__Alternatives_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Alternatives_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getAlternatives_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__3"
+    // InternalOXtype.g:11936:1: rule__XVariableDeclaration__Group__3 : rule__XVariableDeclaration__Group__3__Impl ;
+    public final void rule__XVariableDeclaration__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11940:1: ( rule__XVariableDeclaration__Group__3__Impl )
+            // InternalOXtype.g:11941:2: rule__XVariableDeclaration__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__3"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group__3__Impl"
+    // InternalOXtype.g:11947:1: rule__XVariableDeclaration__Group__3__Impl : ( ( rule__XVariableDeclaration__Group_3__0 )? ) ;
+    public final void rule__XVariableDeclaration__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11951:1: ( ( ( rule__XVariableDeclaration__Group_3__0 )? ) )
+            // InternalOXtype.g:11952:1: ( ( rule__XVariableDeclaration__Group_3__0 )? )
+            {
+            // InternalOXtype.g:11952:1: ( ( rule__XVariableDeclaration__Group_3__0 )? )
+            // InternalOXtype.g:11953:2: ( rule__XVariableDeclaration__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:11954:2: ( rule__XVariableDeclaration__Group_3__0 )?
+            int alt98=2;
+            int LA98_0 = input.LA(1);
+
+            if ( (LA98_0==13) ) {
+                alt98=1;
+            }
+            switch (alt98) {
+                case 1 :
+                    // InternalOXtype.g:11954:3: rule__XVariableDeclaration__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XVariableDeclaration__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0"
+    // InternalOXtype.g:11963:1: rule__XVariableDeclaration__Group_2_0__0 : rule__XVariableDeclaration__Group_2_0__0__Impl ;
+    public final void rule__XVariableDeclaration__Group_2_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11967:1: ( rule__XVariableDeclaration__Group_2_0__0__Impl )
+            // InternalOXtype.g:11968:2: rule__XVariableDeclaration__Group_2_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group_2_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_2_0__0__Impl"
+    // InternalOXtype.g:11974:1: rule__XVariableDeclaration__Group_2_0__0__Impl : ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) ;
+    public final void rule__XVariableDeclaration__Group_2_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11978:1: ( ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) ) )
+            // InternalOXtype.g:11979:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) )
+            {
+            // InternalOXtype.g:11979:1: ( ( rule__XVariableDeclaration__Group_2_0_0__0 ) )
+            // InternalOXtype.g:11980:2: ( rule__XVariableDeclaration__Group_2_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); 
+            }
+            // InternalOXtype.g:11981:2: ( rule__XVariableDeclaration__Group_2_0_0__0 )
+            // InternalOXtype.g:11981:3: rule__XVariableDeclaration__Group_2_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group_2_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_2_0__0__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0"
+    // InternalOXtype.g:11990:1: rule__XVariableDeclaration__Group_2_0_0__0 : rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 ;
+    public final void rule__XVariableDeclaration__Group_2_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:11994:1: ( rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1 )
+            // InternalOXtype.g:11995:2: rule__XVariableDeclaration__Group_2_0_0__0__Impl rule__XVariableDeclaration__Group_2_0_0__1
+            {
+            pushFollow(FOLLOW_9);
+            rule__XVariableDeclaration__Group_2_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group_2_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__0__Impl"
+    // InternalOXtype.g:12002:1: rule__XVariableDeclaration__Group_2_0_0__0__Impl : ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) ;
+    public final void rule__XVariableDeclaration__Group_2_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12006:1: ( ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) ) )
+            // InternalOXtype.g:12007:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) )
+            {
+            // InternalOXtype.g:12007:1: ( ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 ) )
+            // InternalOXtype.g:12008:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); 
+            }
+            // InternalOXtype.g:12009:2: ( rule__XVariableDeclaration__TypeAssignment_2_0_0_0 )
+            // InternalOXtype.g:12009:3: rule__XVariableDeclaration__TypeAssignment_2_0_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__TypeAssignment_2_0_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getTypeAssignment_2_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1"
+    // InternalOXtype.g:12017:1: rule__XVariableDeclaration__Group_2_0_0__1 : rule__XVariableDeclaration__Group_2_0_0__1__Impl ;
+    public final void rule__XVariableDeclaration__Group_2_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12021:1: ( rule__XVariableDeclaration__Group_2_0_0__1__Impl )
+            // InternalOXtype.g:12022:2: rule__XVariableDeclaration__Group_2_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group_2_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_2_0_0__1__Impl"
+    // InternalOXtype.g:12028:1: rule__XVariableDeclaration__Group_2_0_0__1__Impl : ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) ;
+    public final void rule__XVariableDeclaration__Group_2_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12032:1: ( ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) ) )
+            // InternalOXtype.g:12033:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) )
+            {
+            // InternalOXtype.g:12033:1: ( ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 ) )
+            // InternalOXtype.g:12034:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); 
+            }
+            // InternalOXtype.g:12035:2: ( rule__XVariableDeclaration__NameAssignment_2_0_0_1 )
+            // InternalOXtype.g:12035:3: rule__XVariableDeclaration__NameAssignment_2_0_0_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__NameAssignment_2_0_0_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getNameAssignment_2_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_2_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_3__0"
+    // InternalOXtype.g:12044:1: rule__XVariableDeclaration__Group_3__0 : rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 ;
+    public final void rule__XVariableDeclaration__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12048:1: ( rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1 )
+            // InternalOXtype.g:12049:2: rule__XVariableDeclaration__Group_3__0__Impl rule__XVariableDeclaration__Group_3__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XVariableDeclaration__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_3__0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_3__0__Impl"
+    // InternalOXtype.g:12056:1: rule__XVariableDeclaration__Group_3__0__Impl : ( '=' ) ;
+    public final void rule__XVariableDeclaration__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12060:1: ( ( '=' ) )
+            // InternalOXtype.g:12061:1: ( '=' )
+            {
+            // InternalOXtype.g:12061:1: ( '=' )
+            // InternalOXtype.g:12062:2: '='
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); 
+            }
+            match(input,13,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_3__1"
+    // InternalOXtype.g:12071:1: rule__XVariableDeclaration__Group_3__1 : rule__XVariableDeclaration__Group_3__1__Impl ;
+    public final void rule__XVariableDeclaration__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12075:1: ( rule__XVariableDeclaration__Group_3__1__Impl )
+            // InternalOXtype.g:12076:2: rule__XVariableDeclaration__Group_3__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_3__1"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__Group_3__1__Impl"
+    // InternalOXtype.g:12082:1: rule__XVariableDeclaration__Group_3__1__Impl : ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) ;
+    public final void rule__XVariableDeclaration__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12086:1: ( ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) ) )
+            // InternalOXtype.g:12087:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) )
+            {
+            // InternalOXtype.g:12087:1: ( ( rule__XVariableDeclaration__RightAssignment_3_1 ) )
+            // InternalOXtype.g:12088:2: ( rule__XVariableDeclaration__RightAssignment_3_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); 
+            }
+            // InternalOXtype.g:12089:2: ( rule__XVariableDeclaration__RightAssignment_3_1 )
+            // InternalOXtype.g:12089:3: rule__XVariableDeclaration__RightAssignment_3_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XVariableDeclaration__RightAssignment_3_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getRightAssignment_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__JvmFormalParameter__Group__0"
+    // InternalOXtype.g:12098:1: rule__JvmFormalParameter__Group__0 : rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 ;
+    public final void rule__JvmFormalParameter__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12102:1: ( rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1 )
+            // InternalOXtype.g:12103:2: rule__JvmFormalParameter__Group__0__Impl rule__JvmFormalParameter__Group__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__JvmFormalParameter__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmFormalParameter__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmFormalParameter__Group__0"
+
+
+    // $ANTLR start "rule__JvmFormalParameter__Group__0__Impl"
+    // InternalOXtype.g:12110:1: rule__JvmFormalParameter__Group__0__Impl : ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) ;
+    public final void rule__JvmFormalParameter__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12114:1: ( ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? ) )
+            // InternalOXtype.g:12115:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? )
+            {
+            // InternalOXtype.g:12115:1: ( ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )? )
+            // InternalOXtype.g:12116:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); 
+            }
+            // InternalOXtype.g:12117:2: ( rule__JvmFormalParameter__ParameterTypeAssignment_0 )?
+            int alt99=2;
+            int LA99_0 = input.LA(1);
+
+            if ( (LA99_0==RULE_ID) ) {
+                int LA99_1 = input.LA(2);
+
+                if ( (LA99_1==RULE_ID||LA99_1==27||LA99_1==43||LA99_1==58) ) {
+                    alt99=1;
+                }
+            }
+            else if ( (LA99_0==31||LA99_0==53) ) {
+                alt99=1;
+            }
+            switch (alt99) {
+                case 1 :
+                    // InternalOXtype.g:12117:3: rule__JvmFormalParameter__ParameterTypeAssignment_0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmFormalParameter__ParameterTypeAssignment_0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeAssignment_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmFormalParameter__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmFormalParameter__Group__1"
+    // InternalOXtype.g:12125:1: rule__JvmFormalParameter__Group__1 : rule__JvmFormalParameter__Group__1__Impl ;
+    public final void rule__JvmFormalParameter__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12129:1: ( rule__JvmFormalParameter__Group__1__Impl )
+            // InternalOXtype.g:12130:2: rule__JvmFormalParameter__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmFormalParameter__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmFormalParameter__Group__1"
+
+
+    // $ANTLR start "rule__JvmFormalParameter__Group__1__Impl"
+    // InternalOXtype.g:12136:1: rule__JvmFormalParameter__Group__1__Impl : ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) ;
+    public final void rule__JvmFormalParameter__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12140:1: ( ( ( rule__JvmFormalParameter__NameAssignment_1 ) ) )
+            // InternalOXtype.g:12141:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) )
+            {
+            // InternalOXtype.g:12141:1: ( ( rule__JvmFormalParameter__NameAssignment_1 ) )
+            // InternalOXtype.g:12142:2: ( rule__JvmFormalParameter__NameAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); 
+            }
+            // InternalOXtype.g:12143:2: ( rule__JvmFormalParameter__NameAssignment_1 )
+            // InternalOXtype.g:12143:3: rule__JvmFormalParameter__NameAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmFormalParameter__NameAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmFormalParameterAccess().getNameAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmFormalParameter__Group__1__Impl"
+
+
+    // $ANTLR start "rule__FullJvmFormalParameter__Group__0"
+    // InternalOXtype.g:12152:1: rule__FullJvmFormalParameter__Group__0 : rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 ;
+    public final void rule__FullJvmFormalParameter__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12156:1: ( rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1 )
+            // InternalOXtype.g:12157:2: rule__FullJvmFormalParameter__Group__0__Impl rule__FullJvmFormalParameter__Group__1
+            {
+            pushFollow(FOLLOW_9);
+            rule__FullJvmFormalParameter__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__FullJvmFormalParameter__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FullJvmFormalParameter__Group__0"
+
+
+    // $ANTLR start "rule__FullJvmFormalParameter__Group__0__Impl"
+    // InternalOXtype.g:12164:1: rule__FullJvmFormalParameter__Group__0__Impl : ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) ;
+    public final void rule__FullJvmFormalParameter__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12168:1: ( ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) ) )
+            // InternalOXtype.g:12169:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) )
+            {
+            // InternalOXtype.g:12169:1: ( ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 ) )
+            // InternalOXtype.g:12170:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); 
+            }
+            // InternalOXtype.g:12171:2: ( rule__FullJvmFormalParameter__ParameterTypeAssignment_0 )
+            // InternalOXtype.g:12171:3: rule__FullJvmFormalParameter__ParameterTypeAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__FullJvmFormalParameter__ParameterTypeAssignment_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeAssignment_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FullJvmFormalParameter__Group__0__Impl"
+
+
+    // $ANTLR start "rule__FullJvmFormalParameter__Group__1"
+    // InternalOXtype.g:12179:1: rule__FullJvmFormalParameter__Group__1 : rule__FullJvmFormalParameter__Group__1__Impl ;
+    public final void rule__FullJvmFormalParameter__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12183:1: ( rule__FullJvmFormalParameter__Group__1__Impl )
+            // InternalOXtype.g:12184:2: rule__FullJvmFormalParameter__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__FullJvmFormalParameter__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FullJvmFormalParameter__Group__1"
+
+
+    // $ANTLR start "rule__FullJvmFormalParameter__Group__1__Impl"
+    // InternalOXtype.g:12190:1: rule__FullJvmFormalParameter__Group__1__Impl : ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) ;
+    public final void rule__FullJvmFormalParameter__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12194:1: ( ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) ) )
+            // InternalOXtype.g:12195:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) )
+            {
+            // InternalOXtype.g:12195:1: ( ( rule__FullJvmFormalParameter__NameAssignment_1 ) )
+            // InternalOXtype.g:12196:2: ( rule__FullJvmFormalParameter__NameAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); 
+            }
+            // InternalOXtype.g:12197:2: ( rule__FullJvmFormalParameter__NameAssignment_1 )
+            // InternalOXtype.g:12197:3: rule__FullJvmFormalParameter__NameAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__FullJvmFormalParameter__NameAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFullJvmFormalParameterAccess().getNameAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FullJvmFormalParameter__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__0"
+    // InternalOXtype.g:12206:1: rule__XFeatureCall__Group__0 : rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 ;
+    public final void rule__XFeatureCall__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12210:1: ( rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1 )
+            // InternalOXtype.g:12211:2: rule__XFeatureCall__Group__0__Impl rule__XFeatureCall__Group__1
+            {
+            pushFollow(FOLLOW_50);
+            rule__XFeatureCall__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__0"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__0__Impl"
+    // InternalOXtype.g:12218:1: rule__XFeatureCall__Group__0__Impl : ( () ) ;
+    public final void rule__XFeatureCall__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12222:1: ( ( () ) )
+            // InternalOXtype.g:12223:1: ( () )
+            {
+            // InternalOXtype.g:12223:1: ( () )
+            // InternalOXtype.g:12224:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); 
+            }
+            // InternalOXtype.g:12225:2: ()
+            // InternalOXtype.g:12225:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__1"
+    // InternalOXtype.g:12233:1: rule__XFeatureCall__Group__1 : rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 ;
+    public final void rule__XFeatureCall__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12237:1: ( rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2 )
+            // InternalOXtype.g:12238:2: rule__XFeatureCall__Group__1__Impl rule__XFeatureCall__Group__2
+            {
+            pushFollow(FOLLOW_50);
+            rule__XFeatureCall__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__1"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__1__Impl"
+    // InternalOXtype.g:12245:1: rule__XFeatureCall__Group__1__Impl : ( ( rule__XFeatureCall__Group_1__0 )? ) ;
+    public final void rule__XFeatureCall__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12249:1: ( ( ( rule__XFeatureCall__Group_1__0 )? ) )
+            // InternalOXtype.g:12250:1: ( ( rule__XFeatureCall__Group_1__0 )? )
+            {
+            // InternalOXtype.g:12250:1: ( ( rule__XFeatureCall__Group_1__0 )? )
+            // InternalOXtype.g:12251:2: ( rule__XFeatureCall__Group_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:12252:2: ( rule__XFeatureCall__Group_1__0 )?
+            int alt100=2;
+            int LA100_0 = input.LA(1);
+
+            if ( (LA100_0==27) ) {
+                alt100=1;
+            }
+            switch (alt100) {
+                case 1 :
+                    // InternalOXtype.g:12252:3: rule__XFeatureCall__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFeatureCall__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__2"
+    // InternalOXtype.g:12260:1: rule__XFeatureCall__Group__2 : rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 ;
+    public final void rule__XFeatureCall__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12264:1: ( rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3 )
+            // InternalOXtype.g:12265:2: rule__XFeatureCall__Group__2__Impl rule__XFeatureCall__Group__3
+            {
+            pushFollow(FOLLOW_51);
+            rule__XFeatureCall__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__2"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__2__Impl"
+    // InternalOXtype.g:12272:1: rule__XFeatureCall__Group__2__Impl : ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) ;
+    public final void rule__XFeatureCall__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12276:1: ( ( ( rule__XFeatureCall__FeatureAssignment_2 ) ) )
+            // InternalOXtype.g:12277:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) )
+            {
+            // InternalOXtype.g:12277:1: ( ( rule__XFeatureCall__FeatureAssignment_2 ) )
+            // InternalOXtype.g:12278:2: ( rule__XFeatureCall__FeatureAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); 
+            }
+            // InternalOXtype.g:12279:2: ( rule__XFeatureCall__FeatureAssignment_2 )
+            // InternalOXtype.g:12279:3: rule__XFeatureCall__FeatureAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__FeatureAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__3"
+    // InternalOXtype.g:12287:1: rule__XFeatureCall__Group__3 : rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 ;
+    public final void rule__XFeatureCall__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12291:1: ( rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4 )
+            // InternalOXtype.g:12292:2: rule__XFeatureCall__Group__3__Impl rule__XFeatureCall__Group__4
+            {
+            pushFollow(FOLLOW_51);
+            rule__XFeatureCall__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__3"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__3__Impl"
+    // InternalOXtype.g:12299:1: rule__XFeatureCall__Group__3__Impl : ( ( rule__XFeatureCall__Group_3__0 )? ) ;
+    public final void rule__XFeatureCall__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12303:1: ( ( ( rule__XFeatureCall__Group_3__0 )? ) )
+            // InternalOXtype.g:12304:1: ( ( rule__XFeatureCall__Group_3__0 )? )
+            {
+            // InternalOXtype.g:12304:1: ( ( rule__XFeatureCall__Group_3__0 )? )
+            // InternalOXtype.g:12305:2: ( rule__XFeatureCall__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:12306:2: ( rule__XFeatureCall__Group_3__0 )?
+            int alt101=2;
+            alt101 = dfa101.predict(input);
+            switch (alt101) {
+                case 1 :
+                    // InternalOXtype.g:12306:3: rule__XFeatureCall__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFeatureCall__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__4"
+    // InternalOXtype.g:12314:1: rule__XFeatureCall__Group__4 : rule__XFeatureCall__Group__4__Impl ;
+    public final void rule__XFeatureCall__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12318:1: ( rule__XFeatureCall__Group__4__Impl )
+            // InternalOXtype.g:12319:2: rule__XFeatureCall__Group__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__4"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group__4__Impl"
+    // InternalOXtype.g:12325:1: rule__XFeatureCall__Group__4__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) ;
+    public final void rule__XFeatureCall__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12329:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? ) )
+            // InternalOXtype.g:12330:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? )
+            {
+            // InternalOXtype.g:12330:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )? )
+            // InternalOXtype.g:12331:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); 
+            }
+            // InternalOXtype.g:12332:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?
+            int alt102=2;
+            alt102 = dfa102.predict(input);
+            switch (alt102) {
+                case 1 :
+                    // InternalOXtype.g:12332:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFeatureCall__FeatureCallArgumentsAssignment_4();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__0"
+    // InternalOXtype.g:12341:1: rule__XFeatureCall__Group_1__0 : rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 ;
+    public final void rule__XFeatureCall__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12345:1: ( rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1 )
+            // InternalOXtype.g:12346:2: rule__XFeatureCall__Group_1__0__Impl rule__XFeatureCall__Group_1__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__XFeatureCall__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__0"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__0__Impl"
+    // InternalOXtype.g:12353:1: rule__XFeatureCall__Group_1__0__Impl : ( '<' ) ;
+    public final void rule__XFeatureCall__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12357:1: ( ( '<' ) )
+            // InternalOXtype.g:12358:1: ( '<' )
+            {
+            // InternalOXtype.g:12358:1: ( '<' )
+            // InternalOXtype.g:12359:2: '<'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); 
+            }
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__1"
+    // InternalOXtype.g:12368:1: rule__XFeatureCall__Group_1__1 : rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 ;
+    public final void rule__XFeatureCall__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12372:1: ( rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2 )
+            // InternalOXtype.g:12373:2: rule__XFeatureCall__Group_1__1__Impl rule__XFeatureCall__Group_1__2
+            {
+            pushFollow(FOLLOW_53);
+            rule__XFeatureCall__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_1__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__1"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__1__Impl"
+    // InternalOXtype.g:12380:1: rule__XFeatureCall__Group_1__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) ;
+    public final void rule__XFeatureCall__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12384:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) ) )
+            // InternalOXtype.g:12385:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:12385:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 ) )
+            // InternalOXtype.g:12386:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); 
+            }
+            // InternalOXtype.g:12387:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_1 )
+            // InternalOXtype.g:12387:3: rule__XFeatureCall__TypeArgumentsAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__TypeArgumentsAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__2"
+    // InternalOXtype.g:12395:1: rule__XFeatureCall__Group_1__2 : rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 ;
+    public final void rule__XFeatureCall__Group_1__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12399:1: ( rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3 )
+            // InternalOXtype.g:12400:2: rule__XFeatureCall__Group_1__2__Impl rule__XFeatureCall__Group_1__3
+            {
+            pushFollow(FOLLOW_53);
+            rule__XFeatureCall__Group_1__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_1__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__2"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__2__Impl"
+    // InternalOXtype.g:12407:1: rule__XFeatureCall__Group_1__2__Impl : ( ( rule__XFeatureCall__Group_1_2__0 )* ) ;
+    public final void rule__XFeatureCall__Group_1__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12411:1: ( ( ( rule__XFeatureCall__Group_1_2__0 )* ) )
+            // InternalOXtype.g:12412:1: ( ( rule__XFeatureCall__Group_1_2__0 )* )
+            {
+            // InternalOXtype.g:12412:1: ( ( rule__XFeatureCall__Group_1_2__0 )* )
+            // InternalOXtype.g:12413:2: ( rule__XFeatureCall__Group_1_2__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); 
+            }
+            // InternalOXtype.g:12414:2: ( rule__XFeatureCall__Group_1_2__0 )*
+            loop103:
+            do {
+                int alt103=2;
+                int LA103_0 = input.LA(1);
+
+                if ( (LA103_0==55) ) {
+                    alt103=1;
+                }
+
+
+                switch (alt103) {
+            	case 1 :
+            	    // InternalOXtype.g:12414:3: rule__XFeatureCall__Group_1_2__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XFeatureCall__Group_1_2__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop103;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getGroup_1_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__2__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__3"
+    // InternalOXtype.g:12422:1: rule__XFeatureCall__Group_1__3 : rule__XFeatureCall__Group_1__3__Impl ;
+    public final void rule__XFeatureCall__Group_1__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12426:1: ( rule__XFeatureCall__Group_1__3__Impl )
+            // InternalOXtype.g:12427:2: rule__XFeatureCall__Group_1__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_1__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__3"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1__3__Impl"
+    // InternalOXtype.g:12433:1: rule__XFeatureCall__Group_1__3__Impl : ( '>' ) ;
+    public final void rule__XFeatureCall__Group_1__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12437:1: ( ( '>' ) )
+            // InternalOXtype.g:12438:1: ( '>' )
+            {
+            // InternalOXtype.g:12438:1: ( '>' )
+            // InternalOXtype.g:12439:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1__3__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1_2__0"
+    // InternalOXtype.g:12449:1: rule__XFeatureCall__Group_1_2__0 : rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 ;
+    public final void rule__XFeatureCall__Group_1_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12453:1: ( rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1 )
+            // InternalOXtype.g:12454:2: rule__XFeatureCall__Group_1_2__0__Impl rule__XFeatureCall__Group_1_2__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__XFeatureCall__Group_1_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_1_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1_2__0"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1_2__0__Impl"
+    // InternalOXtype.g:12461:1: rule__XFeatureCall__Group_1_2__0__Impl : ( ',' ) ;
+    public final void rule__XFeatureCall__Group_1_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12465:1: ( ( ',' ) )
+            // InternalOXtype.g:12466:1: ( ',' )
+            {
+            // InternalOXtype.g:12466:1: ( ',' )
+            // InternalOXtype.g:12467:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1_2__0__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1_2__1"
+    // InternalOXtype.g:12476:1: rule__XFeatureCall__Group_1_2__1 : rule__XFeatureCall__Group_1_2__1__Impl ;
+    public final void rule__XFeatureCall__Group_1_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12480:1: ( rule__XFeatureCall__Group_1_2__1__Impl )
+            // InternalOXtype.g:12481:2: rule__XFeatureCall__Group_1_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_1_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1_2__1"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_1_2__1__Impl"
+    // InternalOXtype.g:12487:1: rule__XFeatureCall__Group_1_2__1__Impl : ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) ;
+    public final void rule__XFeatureCall__Group_1_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12491:1: ( ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) ) )
+            // InternalOXtype.g:12492:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) )
+            {
+            // InternalOXtype.g:12492:1: ( ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 ) )
+            // InternalOXtype.g:12493:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); 
+            }
+            // InternalOXtype.g:12494:2: ( rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 )
+            // InternalOXtype.g:12494:3: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__TypeArgumentsAssignment_1_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsAssignment_1_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_1_2__1__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3__0"
+    // InternalOXtype.g:12503:1: rule__XFeatureCall__Group_3__0 : rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 ;
+    public final void rule__XFeatureCall__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12507:1: ( rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1 )
+            // InternalOXtype.g:12508:2: rule__XFeatureCall__Group_3__0__Impl rule__XFeatureCall__Group_3__1
+            {
+            pushFollow(FOLLOW_54);
+            rule__XFeatureCall__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3__0"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3__0__Impl"
+    // InternalOXtype.g:12515:1: rule__XFeatureCall__Group_3__0__Impl : ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) ;
+    public final void rule__XFeatureCall__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12519:1: ( ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) ) )
+            // InternalOXtype.g:12520:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) )
+            {
+            // InternalOXtype.g:12520:1: ( ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 ) )
+            // InternalOXtype.g:12521:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); 
+            }
+            // InternalOXtype.g:12522:2: ( rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 )
+            // InternalOXtype.g:12522:3: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__ExplicitOperationCallAssignment_3_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallAssignment_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3__1"
+    // InternalOXtype.g:12530:1: rule__XFeatureCall__Group_3__1 : rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 ;
+    public final void rule__XFeatureCall__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12534:1: ( rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2 )
+            // InternalOXtype.g:12535:2: rule__XFeatureCall__Group_3__1__Impl rule__XFeatureCall__Group_3__2
+            {
+            pushFollow(FOLLOW_54);
+            rule__XFeatureCall__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3__1"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3__1__Impl"
+    // InternalOXtype.g:12542:1: rule__XFeatureCall__Group_3__1__Impl : ( ( rule__XFeatureCall__Alternatives_3_1 )? ) ;
+    public final void rule__XFeatureCall__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12546:1: ( ( ( rule__XFeatureCall__Alternatives_3_1 )? ) )
+            // InternalOXtype.g:12547:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? )
+            {
+            // InternalOXtype.g:12547:1: ( ( rule__XFeatureCall__Alternatives_3_1 )? )
+            // InternalOXtype.g:12548:2: ( rule__XFeatureCall__Alternatives_3_1 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); 
+            }
+            // InternalOXtype.g:12549:2: ( rule__XFeatureCall__Alternatives_3_1 )?
+            int alt104=2;
+            int LA104_0 = input.LA(1);
+
+            if ( ((LA104_0>=RULE_ID && LA104_0<=RULE_STRING)||LA104_0==27||LA104_0==31||(LA104_0>=34 && LA104_0<=35)||LA104_0==40||(LA104_0>=45 && LA104_0<=50)||LA104_0==53||(LA104_0>=57 && LA104_0<=58)||LA104_0==61||LA104_0==63||LA104_0==65||(LA104_0>=69 && LA104_0<=77)||LA104_0==79||LA104_0==86||LA104_0==88) ) {
+                alt104=1;
+            }
+            switch (alt104) {
+                case 1 :
+                    // InternalOXtype.g:12549:3: rule__XFeatureCall__Alternatives_3_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFeatureCall__Alternatives_3_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getAlternatives_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3__2"
+    // InternalOXtype.g:12557:1: rule__XFeatureCall__Group_3__2 : rule__XFeatureCall__Group_3__2__Impl ;
+    public final void rule__XFeatureCall__Group_3__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12561:1: ( rule__XFeatureCall__Group_3__2__Impl )
+            // InternalOXtype.g:12562:2: rule__XFeatureCall__Group_3__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3__2"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3__2__Impl"
+    // InternalOXtype.g:12568:1: rule__XFeatureCall__Group_3__2__Impl : ( ')' ) ;
+    public final void rule__XFeatureCall__Group_3__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12572:1: ( ( ')' ) )
+            // InternalOXtype.g:12573:1: ( ')' )
+            {
+            // InternalOXtype.g:12573:1: ( ')' )
+            // InternalOXtype.g:12574:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3__2__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0"
+    // InternalOXtype.g:12584:1: rule__XFeatureCall__Group_3_1_1__0 : rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 ;
+    public final void rule__XFeatureCall__Group_3_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12588:1: ( rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1 )
+            // InternalOXtype.g:12589:2: rule__XFeatureCall__Group_3_1_1__0__Impl rule__XFeatureCall__Group_3_1_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XFeatureCall__Group_3_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1__0__Impl"
+    // InternalOXtype.g:12596:1: rule__XFeatureCall__Group_3_1_1__0__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) ;
+    public final void rule__XFeatureCall__Group_3_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12600:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) ) )
+            // InternalOXtype.g:12601:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) )
+            {
+            // InternalOXtype.g:12601:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 ) )
+            // InternalOXtype.g:12602:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); 
+            }
+            // InternalOXtype.g:12603:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 )
+            // InternalOXtype.g:12603:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1"
+    // InternalOXtype.g:12611:1: rule__XFeatureCall__Group_3_1_1__1 : rule__XFeatureCall__Group_3_1_1__1__Impl ;
+    public final void rule__XFeatureCall__Group_3_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12615:1: ( rule__XFeatureCall__Group_3_1_1__1__Impl )
+            // InternalOXtype.g:12616:2: rule__XFeatureCall__Group_3_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1__1__Impl"
+    // InternalOXtype.g:12622:1: rule__XFeatureCall__Group_3_1_1__1__Impl : ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) ;
+    public final void rule__XFeatureCall__Group_3_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12626:1: ( ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* ) )
+            // InternalOXtype.g:12627:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* )
+            {
+            // InternalOXtype.g:12627:1: ( ( rule__XFeatureCall__Group_3_1_1_1__0 )* )
+            // InternalOXtype.g:12628:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); 
+            }
+            // InternalOXtype.g:12629:2: ( rule__XFeatureCall__Group_3_1_1_1__0 )*
+            loop105:
+            do {
+                int alt105=2;
+                int LA105_0 = input.LA(1);
+
+                if ( (LA105_0==55) ) {
+                    alt105=1;
+                }
+
+
+                switch (alt105) {
+            	case 1 :
+            	    // InternalOXtype.g:12629:3: rule__XFeatureCall__Group_3_1_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XFeatureCall__Group_3_1_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop105;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getGroup_3_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0"
+    // InternalOXtype.g:12638:1: rule__XFeatureCall__Group_3_1_1_1__0 : rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 ;
+    public final void rule__XFeatureCall__Group_3_1_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12642:1: ( rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1 )
+            // InternalOXtype.g:12643:2: rule__XFeatureCall__Group_3_1_1_1__0__Impl rule__XFeatureCall__Group_3_1_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XFeatureCall__Group_3_1_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3_1_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__0__Impl"
+    // InternalOXtype.g:12650:1: rule__XFeatureCall__Group_3_1_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XFeatureCall__Group_3_1_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12654:1: ( ( ',' ) )
+            // InternalOXtype.g:12655:1: ( ',' )
+            {
+            // InternalOXtype.g:12655:1: ( ',' )
+            // InternalOXtype.g:12656:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1"
+    // InternalOXtype.g:12665:1: rule__XFeatureCall__Group_3_1_1_1__1 : rule__XFeatureCall__Group_3_1_1_1__1__Impl ;
+    public final void rule__XFeatureCall__Group_3_1_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12669:1: ( rule__XFeatureCall__Group_3_1_1_1__1__Impl )
+            // InternalOXtype.g:12670:2: rule__XFeatureCall__Group_3_1_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__Group_3_1_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1"
+
+
+    // $ANTLR start "rule__XFeatureCall__Group_3_1_1_1__1__Impl"
+    // InternalOXtype.g:12676:1: rule__XFeatureCall__Group_3_1_1_1__1__Impl : ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) ;
+    public final void rule__XFeatureCall__Group_3_1_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12680:1: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) ) )
+            // InternalOXtype.g:12681:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) )
+            {
+            // InternalOXtype.g:12681:1: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 ) )
+            // InternalOXtype.g:12682:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); 
+            }
+            // InternalOXtype.g:12683:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 )
+            // InternalOXtype.g:12683:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__Group_3_1_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__0"
+    // InternalOXtype.g:12692:1: rule__XConstructorCall__Group__0 : rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 ;
+    public final void rule__XConstructorCall__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12696:1: ( rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1 )
+            // InternalOXtype.g:12697:2: rule__XConstructorCall__Group__0__Impl rule__XConstructorCall__Group__1
+            {
+            pushFollow(FOLLOW_78);
+            rule__XConstructorCall__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__0"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__0__Impl"
+    // InternalOXtype.g:12704:1: rule__XConstructorCall__Group__0__Impl : ( () ) ;
+    public final void rule__XConstructorCall__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12708:1: ( ( () ) )
+            // InternalOXtype.g:12709:1: ( () )
+            {
+            // InternalOXtype.g:12709:1: ( () )
+            // InternalOXtype.g:12710:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); 
+            }
+            // InternalOXtype.g:12711:2: ()
+            // InternalOXtype.g:12711:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__1"
+    // InternalOXtype.g:12719:1: rule__XConstructorCall__Group__1 : rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 ;
+    public final void rule__XConstructorCall__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12723:1: ( rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2 )
+            // InternalOXtype.g:12724:2: rule__XConstructorCall__Group__1__Impl rule__XConstructorCall__Group__2
+            {
+            pushFollow(FOLLOW_9);
+            rule__XConstructorCall__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__1"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__1__Impl"
+    // InternalOXtype.g:12731:1: rule__XConstructorCall__Group__1__Impl : ( 'new' ) ;
+    public final void rule__XConstructorCall__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12735:1: ( ( 'new' ) )
+            // InternalOXtype.g:12736:1: ( 'new' )
+            {
+            // InternalOXtype.g:12736:1: ( 'new' )
+            // InternalOXtype.g:12737:2: 'new'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); 
+            }
+            match(input,72,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getNewKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__2"
+    // InternalOXtype.g:12746:1: rule__XConstructorCall__Group__2 : rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 ;
+    public final void rule__XConstructorCall__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12750:1: ( rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3 )
+            // InternalOXtype.g:12751:2: rule__XConstructorCall__Group__2__Impl rule__XConstructorCall__Group__3
+            {
+            pushFollow(FOLLOW_79);
+            rule__XConstructorCall__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__2"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__2__Impl"
+    // InternalOXtype.g:12758:1: rule__XConstructorCall__Group__2__Impl : ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) ;
+    public final void rule__XConstructorCall__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12762:1: ( ( ( rule__XConstructorCall__ConstructorAssignment_2 ) ) )
+            // InternalOXtype.g:12763:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) )
+            {
+            // InternalOXtype.g:12763:1: ( ( rule__XConstructorCall__ConstructorAssignment_2 ) )
+            // InternalOXtype.g:12764:2: ( rule__XConstructorCall__ConstructorAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); 
+            }
+            // InternalOXtype.g:12765:2: ( rule__XConstructorCall__ConstructorAssignment_2 )
+            // InternalOXtype.g:12765:3: rule__XConstructorCall__ConstructorAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__ConstructorAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getConstructorAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__3"
+    // InternalOXtype.g:12773:1: rule__XConstructorCall__Group__3 : rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 ;
+    public final void rule__XConstructorCall__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12777:1: ( rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4 )
+            // InternalOXtype.g:12778:2: rule__XConstructorCall__Group__3__Impl rule__XConstructorCall__Group__4
+            {
+            pushFollow(FOLLOW_79);
+            rule__XConstructorCall__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__3"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__3__Impl"
+    // InternalOXtype.g:12785:1: rule__XConstructorCall__Group__3__Impl : ( ( rule__XConstructorCall__Group_3__0 )? ) ;
+    public final void rule__XConstructorCall__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12789:1: ( ( ( rule__XConstructorCall__Group_3__0 )? ) )
+            // InternalOXtype.g:12790:1: ( ( rule__XConstructorCall__Group_3__0 )? )
+            {
+            // InternalOXtype.g:12790:1: ( ( rule__XConstructorCall__Group_3__0 )? )
+            // InternalOXtype.g:12791:2: ( rule__XConstructorCall__Group_3__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getGroup_3()); 
+            }
+            // InternalOXtype.g:12792:2: ( rule__XConstructorCall__Group_3__0 )?
+            int alt106=2;
+            alt106 = dfa106.predict(input);
+            switch (alt106) {
+                case 1 :
+                    // InternalOXtype.g:12792:3: rule__XConstructorCall__Group_3__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XConstructorCall__Group_3__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getGroup_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__4"
+    // InternalOXtype.g:12800:1: rule__XConstructorCall__Group__4 : rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 ;
+    public final void rule__XConstructorCall__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12804:1: ( rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5 )
+            // InternalOXtype.g:12805:2: rule__XConstructorCall__Group__4__Impl rule__XConstructorCall__Group__5
+            {
+            pushFollow(FOLLOW_79);
+            rule__XConstructorCall__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__4"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__4__Impl"
+    // InternalOXtype.g:12812:1: rule__XConstructorCall__Group__4__Impl : ( ( rule__XConstructorCall__Group_4__0 )? ) ;
+    public final void rule__XConstructorCall__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12816:1: ( ( ( rule__XConstructorCall__Group_4__0 )? ) )
+            // InternalOXtype.g:12817:1: ( ( rule__XConstructorCall__Group_4__0 )? )
+            {
+            // InternalOXtype.g:12817:1: ( ( rule__XConstructorCall__Group_4__0 )? )
+            // InternalOXtype.g:12818:2: ( rule__XConstructorCall__Group_4__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getGroup_4()); 
+            }
+            // InternalOXtype.g:12819:2: ( rule__XConstructorCall__Group_4__0 )?
+            int alt107=2;
+            alt107 = dfa107.predict(input);
+            switch (alt107) {
+                case 1 :
+                    // InternalOXtype.g:12819:3: rule__XConstructorCall__Group_4__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XConstructorCall__Group_4__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getGroup_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__5"
+    // InternalOXtype.g:12827:1: rule__XConstructorCall__Group__5 : rule__XConstructorCall__Group__5__Impl ;
+    public final void rule__XConstructorCall__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12831:1: ( rule__XConstructorCall__Group__5__Impl )
+            // InternalOXtype.g:12832:2: rule__XConstructorCall__Group__5__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__5"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group__5__Impl"
+    // InternalOXtype.g:12838:1: rule__XConstructorCall__Group__5__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) ;
+    public final void rule__XConstructorCall__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12842:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? ) )
+            // InternalOXtype.g:12843:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? )
+            {
+            // InternalOXtype.g:12843:1: ( ( rule__XConstructorCall__ArgumentsAssignment_5 )? )
+            // InternalOXtype.g:12844:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); 
+            }
+            // InternalOXtype.g:12845:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?
+            int alt108=2;
+            alt108 = dfa108.predict(input);
+            switch (alt108) {
+                case 1 :
+                    // InternalOXtype.g:12845:3: rule__XConstructorCall__ArgumentsAssignment_5
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XConstructorCall__ArgumentsAssignment_5();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__0"
+    // InternalOXtype.g:12854:1: rule__XConstructorCall__Group_3__0 : rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 ;
+    public final void rule__XConstructorCall__Group_3__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12858:1: ( rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1 )
+            // InternalOXtype.g:12859:2: rule__XConstructorCall__Group_3__0__Impl rule__XConstructorCall__Group_3__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__XConstructorCall__Group_3__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_3__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__0"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__0__Impl"
+    // InternalOXtype.g:12866:1: rule__XConstructorCall__Group_3__0__Impl : ( ( '<' ) ) ;
+    public final void rule__XConstructorCall__Group_3__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12870:1: ( ( ( '<' ) ) )
+            // InternalOXtype.g:12871:1: ( ( '<' ) )
+            {
+            // InternalOXtype.g:12871:1: ( ( '<' ) )
+            // InternalOXtype.g:12872:2: ( '<' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); 
+            }
+            // InternalOXtype.g:12873:2: ( '<' )
+            // InternalOXtype.g:12873:3: '<'
+            {
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__0__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__1"
+    // InternalOXtype.g:12881:1: rule__XConstructorCall__Group_3__1 : rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 ;
+    public final void rule__XConstructorCall__Group_3__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12885:1: ( rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2 )
+            // InternalOXtype.g:12886:2: rule__XConstructorCall__Group_3__1__Impl rule__XConstructorCall__Group_3__2
+            {
+            pushFollow(FOLLOW_53);
+            rule__XConstructorCall__Group_3__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_3__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__1"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__1__Impl"
+    // InternalOXtype.g:12893:1: rule__XConstructorCall__Group_3__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) ;
+    public final void rule__XConstructorCall__Group_3__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12897:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) ) )
+            // InternalOXtype.g:12898:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) )
+            {
+            // InternalOXtype.g:12898:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 ) )
+            // InternalOXtype.g:12899:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); 
+            }
+            // InternalOXtype.g:12900:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_1 )
+            // InternalOXtype.g:12900:3: rule__XConstructorCall__TypeArgumentsAssignment_3_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__TypeArgumentsAssignment_3_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__1__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__2"
+    // InternalOXtype.g:12908:1: rule__XConstructorCall__Group_3__2 : rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 ;
+    public final void rule__XConstructorCall__Group_3__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12912:1: ( rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3 )
+            // InternalOXtype.g:12913:2: rule__XConstructorCall__Group_3__2__Impl rule__XConstructorCall__Group_3__3
+            {
+            pushFollow(FOLLOW_53);
+            rule__XConstructorCall__Group_3__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_3__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__2"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__2__Impl"
+    // InternalOXtype.g:12920:1: rule__XConstructorCall__Group_3__2__Impl : ( ( rule__XConstructorCall__Group_3_2__0 )* ) ;
+    public final void rule__XConstructorCall__Group_3__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12924:1: ( ( ( rule__XConstructorCall__Group_3_2__0 )* ) )
+            // InternalOXtype.g:12925:1: ( ( rule__XConstructorCall__Group_3_2__0 )* )
+            {
+            // InternalOXtype.g:12925:1: ( ( rule__XConstructorCall__Group_3_2__0 )* )
+            // InternalOXtype.g:12926:2: ( rule__XConstructorCall__Group_3_2__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); 
+            }
+            // InternalOXtype.g:12927:2: ( rule__XConstructorCall__Group_3_2__0 )*
+            loop109:
+            do {
+                int alt109=2;
+                int LA109_0 = input.LA(1);
+
+                if ( (LA109_0==55) ) {
+                    alt109=1;
+                }
+
+
+                switch (alt109) {
+            	case 1 :
+            	    // InternalOXtype.g:12927:3: rule__XConstructorCall__Group_3_2__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XConstructorCall__Group_3_2__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop109;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getGroup_3_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__2__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__3"
+    // InternalOXtype.g:12935:1: rule__XConstructorCall__Group_3__3 : rule__XConstructorCall__Group_3__3__Impl ;
+    public final void rule__XConstructorCall__Group_3__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12939:1: ( rule__XConstructorCall__Group_3__3__Impl )
+            // InternalOXtype.g:12940:2: rule__XConstructorCall__Group_3__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_3__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__3"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3__3__Impl"
+    // InternalOXtype.g:12946:1: rule__XConstructorCall__Group_3__3__Impl : ( '>' ) ;
+    public final void rule__XConstructorCall__Group_3__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12950:1: ( ( '>' ) )
+            // InternalOXtype.g:12951:1: ( '>' )
+            {
+            // InternalOXtype.g:12951:1: ( '>' )
+            // InternalOXtype.g:12952:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3__3__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3_2__0"
+    // InternalOXtype.g:12962:1: rule__XConstructorCall__Group_3_2__0 : rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 ;
+    public final void rule__XConstructorCall__Group_3_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12966:1: ( rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1 )
+            // InternalOXtype.g:12967:2: rule__XConstructorCall__Group_3_2__0__Impl rule__XConstructorCall__Group_3_2__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__XConstructorCall__Group_3_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_3_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3_2__0"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3_2__0__Impl"
+    // InternalOXtype.g:12974:1: rule__XConstructorCall__Group_3_2__0__Impl : ( ',' ) ;
+    public final void rule__XConstructorCall__Group_3_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12978:1: ( ( ',' ) )
+            // InternalOXtype.g:12979:1: ( ',' )
+            {
+            // InternalOXtype.g:12979:1: ( ',' )
+            // InternalOXtype.g:12980:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3_2__0__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3_2__1"
+    // InternalOXtype.g:12989:1: rule__XConstructorCall__Group_3_2__1 : rule__XConstructorCall__Group_3_2__1__Impl ;
+    public final void rule__XConstructorCall__Group_3_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:12993:1: ( rule__XConstructorCall__Group_3_2__1__Impl )
+            // InternalOXtype.g:12994:2: rule__XConstructorCall__Group_3_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_3_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3_2__1"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_3_2__1__Impl"
+    // InternalOXtype.g:13000:1: rule__XConstructorCall__Group_3_2__1__Impl : ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) ;
+    public final void rule__XConstructorCall__Group_3_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13004:1: ( ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) ) )
+            // InternalOXtype.g:13005:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) )
+            {
+            // InternalOXtype.g:13005:1: ( ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 ) )
+            // InternalOXtype.g:13006:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); 
+            }
+            // InternalOXtype.g:13007:2: ( rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 )
+            // InternalOXtype.g:13007:3: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__TypeArgumentsAssignment_3_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsAssignment_3_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_3_2__1__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4__0"
+    // InternalOXtype.g:13016:1: rule__XConstructorCall__Group_4__0 : rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 ;
+    public final void rule__XConstructorCall__Group_4__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13020:1: ( rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1 )
+            // InternalOXtype.g:13021:2: rule__XConstructorCall__Group_4__0__Impl rule__XConstructorCall__Group_4__1
+            {
+            pushFollow(FOLLOW_54);
+            rule__XConstructorCall__Group_4__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4__0"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4__0__Impl"
+    // InternalOXtype.g:13028:1: rule__XConstructorCall__Group_4__0__Impl : ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) ;
+    public final void rule__XConstructorCall__Group_4__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13032:1: ( ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) ) )
+            // InternalOXtype.g:13033:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) )
+            {
+            // InternalOXtype.g:13033:1: ( ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 ) )
+            // InternalOXtype.g:13034:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); 
+            }
+            // InternalOXtype.g:13035:2: ( rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 )
+            // InternalOXtype.g:13035:3: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallAssignment_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4__0__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4__1"
+    // InternalOXtype.g:13043:1: rule__XConstructorCall__Group_4__1 : rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 ;
+    public final void rule__XConstructorCall__Group_4__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13047:1: ( rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2 )
+            // InternalOXtype.g:13048:2: rule__XConstructorCall__Group_4__1__Impl rule__XConstructorCall__Group_4__2
+            {
+            pushFollow(FOLLOW_54);
+            rule__XConstructorCall__Group_4__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4__1"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4__1__Impl"
+    // InternalOXtype.g:13055:1: rule__XConstructorCall__Group_4__1__Impl : ( ( rule__XConstructorCall__Alternatives_4_1 )? ) ;
+    public final void rule__XConstructorCall__Group_4__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13059:1: ( ( ( rule__XConstructorCall__Alternatives_4_1 )? ) )
+            // InternalOXtype.g:13060:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? )
+            {
+            // InternalOXtype.g:13060:1: ( ( rule__XConstructorCall__Alternatives_4_1 )? )
+            // InternalOXtype.g:13061:2: ( rule__XConstructorCall__Alternatives_4_1 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); 
+            }
+            // InternalOXtype.g:13062:2: ( rule__XConstructorCall__Alternatives_4_1 )?
+            int alt110=2;
+            int LA110_0 = input.LA(1);
+
+            if ( ((LA110_0>=RULE_ID && LA110_0<=RULE_STRING)||LA110_0==27||LA110_0==31||(LA110_0>=34 && LA110_0<=35)||LA110_0==40||(LA110_0>=45 && LA110_0<=50)||LA110_0==53||(LA110_0>=57 && LA110_0<=58)||LA110_0==61||LA110_0==63||LA110_0==65||(LA110_0>=69 && LA110_0<=77)||LA110_0==79||LA110_0==86||LA110_0==88) ) {
+                alt110=1;
+            }
+            switch (alt110) {
+                case 1 :
+                    // InternalOXtype.g:13062:3: rule__XConstructorCall__Alternatives_4_1
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XConstructorCall__Alternatives_4_1();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getAlternatives_4_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4__1__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4__2"
+    // InternalOXtype.g:13070:1: rule__XConstructorCall__Group_4__2 : rule__XConstructorCall__Group_4__2__Impl ;
+    public final void rule__XConstructorCall__Group_4__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13074:1: ( rule__XConstructorCall__Group_4__2__Impl )
+            // InternalOXtype.g:13075:2: rule__XConstructorCall__Group_4__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4__2"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4__2__Impl"
+    // InternalOXtype.g:13081:1: rule__XConstructorCall__Group_4__2__Impl : ( ')' ) ;
+    public final void rule__XConstructorCall__Group_4__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13085:1: ( ( ')' ) )
+            // InternalOXtype.g:13086:1: ( ')' )
+            {
+            // InternalOXtype.g:13086:1: ( ')' )
+            // InternalOXtype.g:13087:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4__2__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0"
+    // InternalOXtype.g:13097:1: rule__XConstructorCall__Group_4_1_1__0 : rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 ;
+    public final void rule__XConstructorCall__Group_4_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13101:1: ( rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1 )
+            // InternalOXtype.g:13102:2: rule__XConstructorCall__Group_4_1_1__0__Impl rule__XConstructorCall__Group_4_1_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XConstructorCall__Group_4_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1__0__Impl"
+    // InternalOXtype.g:13109:1: rule__XConstructorCall__Group_4_1_1__0__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) ;
+    public final void rule__XConstructorCall__Group_4_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13113:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) ) )
+            // InternalOXtype.g:13114:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) )
+            {
+            // InternalOXtype.g:13114:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 ) )
+            // InternalOXtype.g:13115:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); 
+            }
+            // InternalOXtype.g:13116:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 )
+            // InternalOXtype.g:13116:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__ArgumentsAssignment_4_1_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1"
+    // InternalOXtype.g:13124:1: rule__XConstructorCall__Group_4_1_1__1 : rule__XConstructorCall__Group_4_1_1__1__Impl ;
+    public final void rule__XConstructorCall__Group_4_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13128:1: ( rule__XConstructorCall__Group_4_1_1__1__Impl )
+            // InternalOXtype.g:13129:2: rule__XConstructorCall__Group_4_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1__1__Impl"
+    // InternalOXtype.g:13135:1: rule__XConstructorCall__Group_4_1_1__1__Impl : ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) ;
+    public final void rule__XConstructorCall__Group_4_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13139:1: ( ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* ) )
+            // InternalOXtype.g:13140:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* )
+            {
+            // InternalOXtype.g:13140:1: ( ( rule__XConstructorCall__Group_4_1_1_1__0 )* )
+            // InternalOXtype.g:13141:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); 
+            }
+            // InternalOXtype.g:13142:2: ( rule__XConstructorCall__Group_4_1_1_1__0 )*
+            loop111:
+            do {
+                int alt111=2;
+                int LA111_0 = input.LA(1);
+
+                if ( (LA111_0==55) ) {
+                    alt111=1;
+                }
+
+
+                switch (alt111) {
+            	case 1 :
+            	    // InternalOXtype.g:13142:3: rule__XConstructorCall__Group_4_1_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XConstructorCall__Group_4_1_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop111;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getGroup_4_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0"
+    // InternalOXtype.g:13151:1: rule__XConstructorCall__Group_4_1_1_1__0 : rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 ;
+    public final void rule__XConstructorCall__Group_4_1_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13155:1: ( rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1 )
+            // InternalOXtype.g:13156:2: rule__XConstructorCall__Group_4_1_1_1__0__Impl rule__XConstructorCall__Group_4_1_1_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XConstructorCall__Group_4_1_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4_1_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__0__Impl"
+    // InternalOXtype.g:13163:1: rule__XConstructorCall__Group_4_1_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XConstructorCall__Group_4_1_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13167:1: ( ( ',' ) )
+            // InternalOXtype.g:13168:1: ( ',' )
+            {
+            // InternalOXtype.g:13168:1: ( ',' )
+            // InternalOXtype.g:13169:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1"
+    // InternalOXtype.g:13178:1: rule__XConstructorCall__Group_4_1_1_1__1 : rule__XConstructorCall__Group_4_1_1_1__1__Impl ;
+    public final void rule__XConstructorCall__Group_4_1_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13182:1: ( rule__XConstructorCall__Group_4_1_1_1__1__Impl )
+            // InternalOXtype.g:13183:2: rule__XConstructorCall__Group_4_1_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__Group_4_1_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1"
+
+
+    // $ANTLR start "rule__XConstructorCall__Group_4_1_1_1__1__Impl"
+    // InternalOXtype.g:13189:1: rule__XConstructorCall__Group_4_1_1_1__1__Impl : ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) ;
+    public final void rule__XConstructorCall__Group_4_1_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13193:1: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) ) )
+            // InternalOXtype.g:13194:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) )
+            {
+            // InternalOXtype.g:13194:1: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 ) )
+            // InternalOXtype.g:13195:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); 
+            }
+            // InternalOXtype.g:13196:2: ( rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 )
+            // InternalOXtype.g:13196:3: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__Group_4_1_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__XBooleanLiteral__Group__0"
+    // InternalOXtype.g:13205:1: rule__XBooleanLiteral__Group__0 : rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 ;
+    public final void rule__XBooleanLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13209:1: ( rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1 )
+            // InternalOXtype.g:13210:2: rule__XBooleanLiteral__Group__0__Impl rule__XBooleanLiteral__Group__1
+            {
+            pushFollow(FOLLOW_80);
+            rule__XBooleanLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XBooleanLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBooleanLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XBooleanLiteral__Group__0__Impl"
+    // InternalOXtype.g:13217:1: rule__XBooleanLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XBooleanLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13221:1: ( ( () ) )
+            // InternalOXtype.g:13222:1: ( () )
+            {
+            // InternalOXtype.g:13222:1: ( () )
+            // InternalOXtype.g:13223:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); 
+            }
+            // InternalOXtype.g:13224:2: ()
+            // InternalOXtype.g:13224:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBooleanLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XBooleanLiteral__Group__1"
+    // InternalOXtype.g:13232:1: rule__XBooleanLiteral__Group__1 : rule__XBooleanLiteral__Group__1__Impl ;
+    public final void rule__XBooleanLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13236:1: ( rule__XBooleanLiteral__Group__1__Impl )
+            // InternalOXtype.g:13237:2: rule__XBooleanLiteral__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBooleanLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBooleanLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XBooleanLiteral__Group__1__Impl"
+    // InternalOXtype.g:13243:1: rule__XBooleanLiteral__Group__1__Impl : ( ( rule__XBooleanLiteral__Alternatives_1 ) ) ;
+    public final void rule__XBooleanLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13247:1: ( ( ( rule__XBooleanLiteral__Alternatives_1 ) ) )
+            // InternalOXtype.g:13248:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) )
+            {
+            // InternalOXtype.g:13248:1: ( ( rule__XBooleanLiteral__Alternatives_1 ) )
+            // InternalOXtype.g:13249:2: ( rule__XBooleanLiteral__Alternatives_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); 
+            }
+            // InternalOXtype.g:13250:2: ( rule__XBooleanLiteral__Alternatives_1 )
+            // InternalOXtype.g:13250:3: rule__XBooleanLiteral__Alternatives_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XBooleanLiteral__Alternatives_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBooleanLiteralAccess().getAlternatives_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBooleanLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XNullLiteral__Group__0"
+    // InternalOXtype.g:13259:1: rule__XNullLiteral__Group__0 : rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 ;
+    public final void rule__XNullLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13263:1: ( rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1 )
+            // InternalOXtype.g:13264:2: rule__XNullLiteral__Group__0__Impl rule__XNullLiteral__Group__1
+            {
+            pushFollow(FOLLOW_81);
+            rule__XNullLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XNullLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNullLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XNullLiteral__Group__0__Impl"
+    // InternalOXtype.g:13271:1: rule__XNullLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XNullLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13275:1: ( ( () ) )
+            // InternalOXtype.g:13276:1: ( () )
+            {
+            // InternalOXtype.g:13276:1: ( () )
+            // InternalOXtype.g:13277:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); 
+            }
+            // InternalOXtype.g:13278:2: ()
+            // InternalOXtype.g:13278:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNullLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XNullLiteral__Group__1"
+    // InternalOXtype.g:13286:1: rule__XNullLiteral__Group__1 : rule__XNullLiteral__Group__1__Impl ;
+    public final void rule__XNullLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13290:1: ( rule__XNullLiteral__Group__1__Impl )
+            // InternalOXtype.g:13291:2: rule__XNullLiteral__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XNullLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNullLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XNullLiteral__Group__1__Impl"
+    // InternalOXtype.g:13297:1: rule__XNullLiteral__Group__1__Impl : ( 'null' ) ;
+    public final void rule__XNullLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13301:1: ( ( 'null' ) )
+            // InternalOXtype.g:13302:1: ( 'null' )
+            {
+            // InternalOXtype.g:13302:1: ( 'null' )
+            // InternalOXtype.g:13303:2: 'null'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); 
+            }
+            match(input,73,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNullLiteralAccess().getNullKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNullLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XNumberLiteral__Group__0"
+    // InternalOXtype.g:13313:1: rule__XNumberLiteral__Group__0 : rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 ;
+    public final void rule__XNumberLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13317:1: ( rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1 )
+            // InternalOXtype.g:13318:2: rule__XNumberLiteral__Group__0__Impl rule__XNumberLiteral__Group__1
+            {
+            pushFollow(FOLLOW_82);
+            rule__XNumberLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XNumberLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNumberLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XNumberLiteral__Group__0__Impl"
+    // InternalOXtype.g:13325:1: rule__XNumberLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XNumberLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13329:1: ( ( () ) )
+            // InternalOXtype.g:13330:1: ( () )
+            {
+            // InternalOXtype.g:13330:1: ( () )
+            // InternalOXtype.g:13331:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); 
+            }
+            // InternalOXtype.g:13332:2: ()
+            // InternalOXtype.g:13332:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNumberLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XNumberLiteral__Group__1"
+    // InternalOXtype.g:13340:1: rule__XNumberLiteral__Group__1 : rule__XNumberLiteral__Group__1__Impl ;
+    public final void rule__XNumberLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13344:1: ( rule__XNumberLiteral__Group__1__Impl )
+            // InternalOXtype.g:13345:2: rule__XNumberLiteral__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XNumberLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNumberLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XNumberLiteral__Group__1__Impl"
+    // InternalOXtype.g:13351:1: rule__XNumberLiteral__Group__1__Impl : ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) ;
+    public final void rule__XNumberLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13355:1: ( ( ( rule__XNumberLiteral__ValueAssignment_1 ) ) )
+            // InternalOXtype.g:13356:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) )
+            {
+            // InternalOXtype.g:13356:1: ( ( rule__XNumberLiteral__ValueAssignment_1 ) )
+            // InternalOXtype.g:13357:2: ( rule__XNumberLiteral__ValueAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); 
+            }
+            // InternalOXtype.g:13358:2: ( rule__XNumberLiteral__ValueAssignment_1 )
+            // InternalOXtype.g:13358:3: rule__XNumberLiteral__ValueAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XNumberLiteral__ValueAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNumberLiteralAccess().getValueAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNumberLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XStringLiteral__Group__0"
+    // InternalOXtype.g:13367:1: rule__XStringLiteral__Group__0 : rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 ;
+    public final void rule__XStringLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13371:1: ( rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1 )
+            // InternalOXtype.g:13372:2: rule__XStringLiteral__Group__0__Impl rule__XStringLiteral__Group__1
+            {
+            pushFollow(FOLLOW_83);
+            rule__XStringLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XStringLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XStringLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XStringLiteral__Group__0__Impl"
+    // InternalOXtype.g:13379:1: rule__XStringLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XStringLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13383:1: ( ( () ) )
+            // InternalOXtype.g:13384:1: ( () )
+            {
+            // InternalOXtype.g:13384:1: ( () )
+            // InternalOXtype.g:13385:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); 
+            }
+            // InternalOXtype.g:13386:2: ()
+            // InternalOXtype.g:13386:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XStringLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XStringLiteral__Group__1"
+    // InternalOXtype.g:13394:1: rule__XStringLiteral__Group__1 : rule__XStringLiteral__Group__1__Impl ;
+    public final void rule__XStringLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13398:1: ( rule__XStringLiteral__Group__1__Impl )
+            // InternalOXtype.g:13399:2: rule__XStringLiteral__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XStringLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XStringLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XStringLiteral__Group__1__Impl"
+    // InternalOXtype.g:13405:1: rule__XStringLiteral__Group__1__Impl : ( ( rule__XStringLiteral__ValueAssignment_1 ) ) ;
+    public final void rule__XStringLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13409:1: ( ( ( rule__XStringLiteral__ValueAssignment_1 ) ) )
+            // InternalOXtype.g:13410:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) )
+            {
+            // InternalOXtype.g:13410:1: ( ( rule__XStringLiteral__ValueAssignment_1 ) )
+            // InternalOXtype.g:13411:2: ( rule__XStringLiteral__ValueAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); 
+            }
+            // InternalOXtype.g:13412:2: ( rule__XStringLiteral__ValueAssignment_1 )
+            // InternalOXtype.g:13412:3: rule__XStringLiteral__ValueAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XStringLiteral__ValueAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXStringLiteralAccess().getValueAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XStringLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__0"
+    // InternalOXtype.g:13421:1: rule__XTypeLiteral__Group__0 : rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 ;
+    public final void rule__XTypeLiteral__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13425:1: ( rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1 )
+            // InternalOXtype.g:13426:2: rule__XTypeLiteral__Group__0__Impl rule__XTypeLiteral__Group__1
+            {
+            pushFollow(FOLLOW_84);
+            rule__XTypeLiteral__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__0"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__0__Impl"
+    // InternalOXtype.g:13433:1: rule__XTypeLiteral__Group__0__Impl : ( () ) ;
+    public final void rule__XTypeLiteral__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13437:1: ( ( () ) )
+            // InternalOXtype.g:13438:1: ( () )
+            {
+            // InternalOXtype.g:13438:1: ( () )
+            // InternalOXtype.g:13439:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); 
+            }
+            // InternalOXtype.g:13440:2: ()
+            // InternalOXtype.g:13440:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__1"
+    // InternalOXtype.g:13448:1: rule__XTypeLiteral__Group__1 : rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 ;
+    public final void rule__XTypeLiteral__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13452:1: ( rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2 )
+            // InternalOXtype.g:13453:2: rule__XTypeLiteral__Group__1__Impl rule__XTypeLiteral__Group__2
+            {
+            pushFollow(FOLLOW_11);
+            rule__XTypeLiteral__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__1"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__1__Impl"
+    // InternalOXtype.g:13460:1: rule__XTypeLiteral__Group__1__Impl : ( 'typeof' ) ;
+    public final void rule__XTypeLiteral__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13464:1: ( ( 'typeof' ) )
+            // InternalOXtype.g:13465:1: ( 'typeof' )
+            {
+            // InternalOXtype.g:13465:1: ( 'typeof' )
+            // InternalOXtype.g:13466:2: 'typeof'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); 
+            }
+            match(input,74,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__2"
+    // InternalOXtype.g:13475:1: rule__XTypeLiteral__Group__2 : rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 ;
+    public final void rule__XTypeLiteral__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13479:1: ( rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3 )
+            // InternalOXtype.g:13480:2: rule__XTypeLiteral__Group__2__Impl rule__XTypeLiteral__Group__3
+            {
+            pushFollow(FOLLOW_9);
+            rule__XTypeLiteral__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__2"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__2__Impl"
+    // InternalOXtype.g:13487:1: rule__XTypeLiteral__Group__2__Impl : ( '(' ) ;
+    public final void rule__XTypeLiteral__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13491:1: ( ( '(' ) )
+            // InternalOXtype.g:13492:1: ( '(' )
+            {
+            // InternalOXtype.g:13492:1: ( '(' )
+            // InternalOXtype.g:13493:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__3"
+    // InternalOXtype.g:13502:1: rule__XTypeLiteral__Group__3 : rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 ;
+    public final void rule__XTypeLiteral__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13506:1: ( rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4 )
+            // InternalOXtype.g:13507:2: rule__XTypeLiteral__Group__3__Impl rule__XTypeLiteral__Group__4
+            {
+            pushFollow(FOLLOW_85);
+            rule__XTypeLiteral__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__3"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__3__Impl"
+    // InternalOXtype.g:13514:1: rule__XTypeLiteral__Group__3__Impl : ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) ;
+    public final void rule__XTypeLiteral__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13518:1: ( ( ( rule__XTypeLiteral__TypeAssignment_3 ) ) )
+            // InternalOXtype.g:13519:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) )
+            {
+            // InternalOXtype.g:13519:1: ( ( rule__XTypeLiteral__TypeAssignment_3 ) )
+            // InternalOXtype.g:13520:2: ( rule__XTypeLiteral__TypeAssignment_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); 
+            }
+            // InternalOXtype.g:13521:2: ( rule__XTypeLiteral__TypeAssignment_3 )
+            // InternalOXtype.g:13521:3: rule__XTypeLiteral__TypeAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__TypeAssignment_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getTypeAssignment_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__4"
+    // InternalOXtype.g:13529:1: rule__XTypeLiteral__Group__4 : rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 ;
+    public final void rule__XTypeLiteral__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13533:1: ( rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5 )
+            // InternalOXtype.g:13534:2: rule__XTypeLiteral__Group__4__Impl rule__XTypeLiteral__Group__5
+            {
+            pushFollow(FOLLOW_85);
+            rule__XTypeLiteral__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__5();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__4"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__4__Impl"
+    // InternalOXtype.g:13541:1: rule__XTypeLiteral__Group__4__Impl : ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) ;
+    public final void rule__XTypeLiteral__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13545:1: ( ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* ) )
+            // InternalOXtype.g:13546:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* )
+            {
+            // InternalOXtype.g:13546:1: ( ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )* )
+            // InternalOXtype.g:13547:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); 
+            }
+            // InternalOXtype.g:13548:2: ( rule__XTypeLiteral__ArrayDimensionsAssignment_4 )*
+            loop112:
+            do {
+                int alt112=2;
+                int LA112_0 = input.LA(1);
+
+                if ( (LA112_0==58) ) {
+                    alt112=1;
+                }
+
+
+                switch (alt112) {
+            	case 1 :
+            	    // InternalOXtype.g:13548:3: rule__XTypeLiteral__ArrayDimensionsAssignment_4
+            	    {
+            	    pushFollow(FOLLOW_86);
+            	    rule__XTypeLiteral__ArrayDimensionsAssignment_4();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop112;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsAssignment_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__4__Impl"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__5"
+    // InternalOXtype.g:13556:1: rule__XTypeLiteral__Group__5 : rule__XTypeLiteral__Group__5__Impl ;
+    public final void rule__XTypeLiteral__Group__5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13560:1: ( rule__XTypeLiteral__Group__5__Impl )
+            // InternalOXtype.g:13561:2: rule__XTypeLiteral__Group__5__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTypeLiteral__Group__5__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__5"
+
+
+    // $ANTLR start "rule__XTypeLiteral__Group__5__Impl"
+    // InternalOXtype.g:13567:1: rule__XTypeLiteral__Group__5__Impl : ( ')' ) ;
+    public final void rule__XTypeLiteral__Group__5__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13571:1: ( ( ')' ) )
+            // InternalOXtype.g:13572:1: ( ')' )
+            {
+            // InternalOXtype.g:13572:1: ( ')' )
+            // InternalOXtype.g:13573:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__Group__5__Impl"
+
+
+    // $ANTLR start "rule__XThrowExpression__Group__0"
+    // InternalOXtype.g:13583:1: rule__XThrowExpression__Group__0 : rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 ;
+    public final void rule__XThrowExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13587:1: ( rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1 )
+            // InternalOXtype.g:13588:2: rule__XThrowExpression__Group__0__Impl rule__XThrowExpression__Group__1
+            {
+            pushFollow(FOLLOW_87);
+            rule__XThrowExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XThrowExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__Group__0"
+
+
+    // $ANTLR start "rule__XThrowExpression__Group__0__Impl"
+    // InternalOXtype.g:13595:1: rule__XThrowExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XThrowExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13599:1: ( ( () ) )
+            // InternalOXtype.g:13600:1: ( () )
+            {
+            // InternalOXtype.g:13600:1: ( () )
+            // InternalOXtype.g:13601:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); 
+            }
+            // InternalOXtype.g:13602:2: ()
+            // InternalOXtype.g:13602:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XThrowExpression__Group__1"
+    // InternalOXtype.g:13610:1: rule__XThrowExpression__Group__1 : rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 ;
+    public final void rule__XThrowExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13614:1: ( rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2 )
+            // InternalOXtype.g:13615:2: rule__XThrowExpression__Group__1__Impl rule__XThrowExpression__Group__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__XThrowExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XThrowExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__Group__1"
+
+
+    // $ANTLR start "rule__XThrowExpression__Group__1__Impl"
+    // InternalOXtype.g:13622:1: rule__XThrowExpression__Group__1__Impl : ( 'throw' ) ;
+    public final void rule__XThrowExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13626:1: ( ( 'throw' ) )
+            // InternalOXtype.g:13627:1: ( 'throw' )
+            {
+            // InternalOXtype.g:13627:1: ( 'throw' )
+            // InternalOXtype.g:13628:2: 'throw'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); 
+            }
+            match(input,75,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XThrowExpression__Group__2"
+    // InternalOXtype.g:13637:1: rule__XThrowExpression__Group__2 : rule__XThrowExpression__Group__2__Impl ;
+    public final void rule__XThrowExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13641:1: ( rule__XThrowExpression__Group__2__Impl )
+            // InternalOXtype.g:13642:2: rule__XThrowExpression__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XThrowExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__Group__2"
+
+
+    // $ANTLR start "rule__XThrowExpression__Group__2__Impl"
+    // InternalOXtype.g:13648:1: rule__XThrowExpression__Group__2__Impl : ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) ;
+    public final void rule__XThrowExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13652:1: ( ( ( rule__XThrowExpression__ExpressionAssignment_2 ) ) )
+            // InternalOXtype.g:13653:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) )
+            {
+            // InternalOXtype.g:13653:1: ( ( rule__XThrowExpression__ExpressionAssignment_2 ) )
+            // InternalOXtype.g:13654:2: ( rule__XThrowExpression__ExpressionAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); 
+            }
+            // InternalOXtype.g:13655:2: ( rule__XThrowExpression__ExpressionAssignment_2 )
+            // InternalOXtype.g:13655:3: rule__XThrowExpression__ExpressionAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XThrowExpression__ExpressionAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXThrowExpressionAccess().getExpressionAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XReturnExpression__Group__0"
+    // InternalOXtype.g:13664:1: rule__XReturnExpression__Group__0 : rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 ;
+    public final void rule__XReturnExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13668:1: ( rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1 )
+            // InternalOXtype.g:13669:2: rule__XReturnExpression__Group__0__Impl rule__XReturnExpression__Group__1
+            {
+            pushFollow(FOLLOW_88);
+            rule__XReturnExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XReturnExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__Group__0"
+
+
+    // $ANTLR start "rule__XReturnExpression__Group__0__Impl"
+    // InternalOXtype.g:13676:1: rule__XReturnExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XReturnExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13680:1: ( ( () ) )
+            // InternalOXtype.g:13681:1: ( () )
+            {
+            // InternalOXtype.g:13681:1: ( () )
+            // InternalOXtype.g:13682:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); 
+            }
+            // InternalOXtype.g:13683:2: ()
+            // InternalOXtype.g:13683:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XReturnExpression__Group__1"
+    // InternalOXtype.g:13691:1: rule__XReturnExpression__Group__1 : rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 ;
+    public final void rule__XReturnExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13695:1: ( rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2 )
+            // InternalOXtype.g:13696:2: rule__XReturnExpression__Group__1__Impl rule__XReturnExpression__Group__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__XReturnExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XReturnExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__Group__1"
+
+
+    // $ANTLR start "rule__XReturnExpression__Group__1__Impl"
+    // InternalOXtype.g:13703:1: rule__XReturnExpression__Group__1__Impl : ( 'return' ) ;
+    public final void rule__XReturnExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13707:1: ( ( 'return' ) )
+            // InternalOXtype.g:13708:1: ( 'return' )
+            {
+            // InternalOXtype.g:13708:1: ( 'return' )
+            // InternalOXtype.g:13709:2: 'return'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); 
+            }
+            match(input,76,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XReturnExpression__Group__2"
+    // InternalOXtype.g:13718:1: rule__XReturnExpression__Group__2 : rule__XReturnExpression__Group__2__Impl ;
+    public final void rule__XReturnExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13722:1: ( rule__XReturnExpression__Group__2__Impl )
+            // InternalOXtype.g:13723:2: rule__XReturnExpression__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XReturnExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__Group__2"
+
+
+    // $ANTLR start "rule__XReturnExpression__Group__2__Impl"
+    // InternalOXtype.g:13729:1: rule__XReturnExpression__Group__2__Impl : ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) ;
+    public final void rule__XReturnExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13733:1: ( ( ( rule__XReturnExpression__ExpressionAssignment_2 )? ) )
+            // InternalOXtype.g:13734:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? )
+            {
+            // InternalOXtype.g:13734:1: ( ( rule__XReturnExpression__ExpressionAssignment_2 )? )
+            // InternalOXtype.g:13735:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); 
+            }
+            // InternalOXtype.g:13736:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?
+            int alt113=2;
+            alt113 = dfa113.predict(input);
+            switch (alt113) {
+                case 1 :
+                    // InternalOXtype.g:13736:3: rule__XReturnExpression__ExpressionAssignment_2
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XReturnExpression__ExpressionAssignment_2();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXReturnExpressionAccess().getExpressionAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0"
+    // InternalOXtype.g:13745:1: rule__XTryCatchFinallyExpression__Group__0 : rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 ;
+    public final void rule__XTryCatchFinallyExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13749:1: ( rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1 )
+            // InternalOXtype.g:13750:2: rule__XTryCatchFinallyExpression__Group__0__Impl rule__XTryCatchFinallyExpression__Group__1
+            {
+            pushFollow(FOLLOW_89);
+            rule__XTryCatchFinallyExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__0__Impl"
+    // InternalOXtype.g:13757:1: rule__XTryCatchFinallyExpression__Group__0__Impl : ( () ) ;
+    public final void rule__XTryCatchFinallyExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13761:1: ( ( () ) )
+            // InternalOXtype.g:13762:1: ( () )
+            {
+            // InternalOXtype.g:13762:1: ( () )
+            // InternalOXtype.g:13763:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); 
+            }
+            // InternalOXtype.g:13764:2: ()
+            // InternalOXtype.g:13764:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1"
+    // InternalOXtype.g:13772:1: rule__XTryCatchFinallyExpression__Group__1 : rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 ;
+    public final void rule__XTryCatchFinallyExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13776:1: ( rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2 )
+            // InternalOXtype.g:13777:2: rule__XTryCatchFinallyExpression__Group__1__Impl rule__XTryCatchFinallyExpression__Group__2
+            {
+            pushFollow(FOLLOW_15);
+            rule__XTryCatchFinallyExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__1__Impl"
+    // InternalOXtype.g:13784:1: rule__XTryCatchFinallyExpression__Group__1__Impl : ( 'try' ) ;
+    public final void rule__XTryCatchFinallyExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13788:1: ( ( 'try' ) )
+            // InternalOXtype.g:13789:1: ( 'try' )
+            {
+            // InternalOXtype.g:13789:1: ( 'try' )
+            // InternalOXtype.g:13790:2: 'try'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); 
+            }
+            match(input,77,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2"
+    // InternalOXtype.g:13799:1: rule__XTryCatchFinallyExpression__Group__2 : rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 ;
+    public final void rule__XTryCatchFinallyExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13803:1: ( rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3 )
+            // InternalOXtype.g:13804:2: rule__XTryCatchFinallyExpression__Group__2__Impl rule__XTryCatchFinallyExpression__Group__3
+            {
+            pushFollow(FOLLOW_90);
+            rule__XTryCatchFinallyExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__2__Impl"
+    // InternalOXtype.g:13811:1: rule__XTryCatchFinallyExpression__Group__2__Impl : ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) ;
+    public final void rule__XTryCatchFinallyExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13815:1: ( ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) ) )
+            // InternalOXtype.g:13816:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) )
+            {
+            // InternalOXtype.g:13816:1: ( ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 ) )
+            // InternalOXtype.g:13817:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); 
+            }
+            // InternalOXtype.g:13818:2: ( rule__XTryCatchFinallyExpression__ExpressionAssignment_2 )
+            // InternalOXtype.g:13818:3: rule__XTryCatchFinallyExpression__ExpressionAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__ExpressionAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3"
+    // InternalOXtype.g:13826:1: rule__XTryCatchFinallyExpression__Group__3 : rule__XTryCatchFinallyExpression__Group__3__Impl ;
+    public final void rule__XTryCatchFinallyExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13830:1: ( rule__XTryCatchFinallyExpression__Group__3__Impl )
+            // InternalOXtype.g:13831:2: rule__XTryCatchFinallyExpression__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group__3__Impl"
+    // InternalOXtype.g:13837:1: rule__XTryCatchFinallyExpression__Group__3__Impl : ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) ;
+    public final void rule__XTryCatchFinallyExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13841:1: ( ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) ) )
+            // InternalOXtype.g:13842:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) )
+            {
+            // InternalOXtype.g:13842:1: ( ( rule__XTryCatchFinallyExpression__Alternatives_3 ) )
+            // InternalOXtype.g:13843:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); 
+            }
+            // InternalOXtype.g:13844:2: ( rule__XTryCatchFinallyExpression__Alternatives_3 )
+            // InternalOXtype.g:13844:3: rule__XTryCatchFinallyExpression__Alternatives_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Alternatives_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getAlternatives_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0"
+    // InternalOXtype.g:13853:1: rule__XTryCatchFinallyExpression__Group_3_0__0 : rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13857:1: ( rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1 )
+            // InternalOXtype.g:13858:2: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl rule__XTryCatchFinallyExpression__Group_3_0__1
+            {
+            pushFollow(FOLLOW_91);
+            rule__XTryCatchFinallyExpression__Group_3_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group_3_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl"
+    // InternalOXtype.g:13865:1: rule__XTryCatchFinallyExpression__Group_3_0__0__Impl : ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13869:1: ( ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) ) )
+            // InternalOXtype.g:13870:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) )
+            {
+            // InternalOXtype.g:13870:1: ( ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* ) )
+            // InternalOXtype.g:13871:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) ) ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* )
+            {
+            // InternalOXtype.g:13871:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 ) )
+            // InternalOXtype.g:13872:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); 
+            }
+            // InternalOXtype.g:13873:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )
+            // InternalOXtype.g:13873:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+            {
+            pushFollow(FOLLOW_92);
+            rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); 
+            }
+
+            }
+
+            // InternalOXtype.g:13876:2: ( ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )* )
+            // InternalOXtype.g:13877:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); 
+            }
+            // InternalOXtype.g:13878:3: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )*
+            loop114:
+            do {
+                int alt114=2;
+                int LA114_0 = input.LA(1);
+
+                if ( (LA114_0==80) ) {
+                    int LA114_2 = input.LA(2);
+
+                    if ( (synpred158_InternalOXtype()) ) {
+                        alt114=1;
+                    }
+
+
+                }
+
+
+                switch (alt114) {
+            	case 1 :
+            	    // InternalOXtype.g:13878:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+            	    {
+            	    pushFollow(FOLLOW_92);
+            	    rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop114;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesAssignment_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__0__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1"
+    // InternalOXtype.g:13887:1: rule__XTryCatchFinallyExpression__Group_3_0__1 : rule__XTryCatchFinallyExpression__Group_3_0__1__Impl ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13891:1: ( rule__XTryCatchFinallyExpression__Group_3_0__1__Impl )
+            // InternalOXtype.g:13892:2: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group_3_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl"
+    // InternalOXtype.g:13898:1: rule__XTryCatchFinallyExpression__Group_3_0__1__Impl : ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13902:1: ( ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? ) )
+            // InternalOXtype.g:13903:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? )
+            {
+            // InternalOXtype.g:13903:1: ( ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )? )
+            // InternalOXtype.g:13904:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); 
+            }
+            // InternalOXtype.g:13905:2: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )?
+            int alt115=2;
+            int LA115_0 = input.LA(1);
+
+            if ( (LA115_0==78) ) {
+                int LA115_1 = input.LA(2);
+
+                if ( (synpred159_InternalOXtype()) ) {
+                    alt115=1;
+                }
+            }
+            switch (alt115) {
+                case 1 :
+                    // InternalOXtype.g:13905:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XTryCatchFinallyExpression__Group_3_0_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup_3_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0__1__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0"
+    // InternalOXtype.g:13914:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0 : rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13918:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1 )
+            // InternalOXtype.g:13919:2: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_0_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group_3_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl"
+    // InternalOXtype.g:13926:1: rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl : ( ( 'finally' ) ) ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13930:1: ( ( ( 'finally' ) ) )
+            // InternalOXtype.g:13931:1: ( ( 'finally' ) )
+            {
+            // InternalOXtype.g:13931:1: ( ( 'finally' ) )
+            // InternalOXtype.g:13932:2: ( 'finally' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); 
+            }
+            // InternalOXtype.g:13933:2: ( 'finally' )
+            // InternalOXtype.g:13933:3: 'finally'
+            {
+            match(input,78,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1"
+    // InternalOXtype.g:13941:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1 : rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13945:1: ( rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl )
+            // InternalOXtype.g:13946:2: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl"
+    // InternalOXtype.g:13952:1: rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13956:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) ) )
+            // InternalOXtype.g:13957:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) )
+            {
+            // InternalOXtype.g:13957:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 ) )
+            // InternalOXtype.g:13958:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); 
+            }
+            // InternalOXtype.g:13959:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 )
+            // InternalOXtype.g:13959:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0"
+    // InternalOXtype.g:13968:1: rule__XTryCatchFinallyExpression__Group_3_1__0 : rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13972:1: ( rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1 )
+            // InternalOXtype.g:13973:2: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl rule__XTryCatchFinallyExpression__Group_3_1__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XTryCatchFinallyExpression__Group_3_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group_3_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl"
+    // InternalOXtype.g:13980:1: rule__XTryCatchFinallyExpression__Group_3_1__0__Impl : ( 'finally' ) ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13984:1: ( ( 'finally' ) )
+            // InternalOXtype.g:13985:1: ( 'finally' )
+            {
+            // InternalOXtype.g:13985:1: ( 'finally' )
+            // InternalOXtype.g:13986:2: 'finally'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); 
+            }
+            match(input,78,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__0__Impl"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1"
+    // InternalOXtype.g:13995:1: rule__XTryCatchFinallyExpression__Group_3_1__1 : rule__XTryCatchFinallyExpression__Group_3_1__1__Impl ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:13999:1: ( rule__XTryCatchFinallyExpression__Group_3_1__1__Impl )
+            // InternalOXtype.g:14000:2: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__Group_3_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl"
+    // InternalOXtype.g:14006:1: rule__XTryCatchFinallyExpression__Group_3_1__1__Impl : ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) ;
+    public final void rule__XTryCatchFinallyExpression__Group_3_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14010:1: ( ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) ) )
+            // InternalOXtype.g:14011:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) )
+            {
+            // InternalOXtype.g:14011:1: ( ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 ) )
+            // InternalOXtype.g:14012:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); 
+            }
+            // InternalOXtype.g:14013:2: ( rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 )
+            // InternalOXtype.g:14013:3: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionAssignment_3_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__Group_3_1__1__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__0"
+    // InternalOXtype.g:14022:1: rule__XSynchronizedExpression__Group__0 : rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 ;
+    public final void rule__XSynchronizedExpression__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14026:1: ( rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1 )
+            // InternalOXtype.g:14027:2: rule__XSynchronizedExpression__Group__0__Impl rule__XSynchronizedExpression__Group__1
+            {
+            pushFollow(FOLLOW_15);
+            rule__XSynchronizedExpression__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__0"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__0__Impl"
+    // InternalOXtype.g:14034:1: rule__XSynchronizedExpression__Group__0__Impl : ( ( rule__XSynchronizedExpression__Group_0__0 ) ) ;
+    public final void rule__XSynchronizedExpression__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14038:1: ( ( ( rule__XSynchronizedExpression__Group_0__0 ) ) )
+            // InternalOXtype.g:14039:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) )
+            {
+            // InternalOXtype.g:14039:1: ( ( rule__XSynchronizedExpression__Group_0__0 ) )
+            // InternalOXtype.g:14040:2: ( rule__XSynchronizedExpression__Group_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); 
+            }
+            // InternalOXtype.g:14041:2: ( rule__XSynchronizedExpression__Group_0__0 )
+            // InternalOXtype.g:14041:3: rule__XSynchronizedExpression__Group_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__1"
+    // InternalOXtype.g:14049:1: rule__XSynchronizedExpression__Group__1 : rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 ;
+    public final void rule__XSynchronizedExpression__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14053:1: ( rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2 )
+            // InternalOXtype.g:14054:2: rule__XSynchronizedExpression__Group__1__Impl rule__XSynchronizedExpression__Group__2
+            {
+            pushFollow(FOLLOW_61);
+            rule__XSynchronizedExpression__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__1"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__1__Impl"
+    // InternalOXtype.g:14061:1: rule__XSynchronizedExpression__Group__1__Impl : ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) ;
+    public final void rule__XSynchronizedExpression__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14065:1: ( ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) ) )
+            // InternalOXtype.g:14066:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) )
+            {
+            // InternalOXtype.g:14066:1: ( ( rule__XSynchronizedExpression__ParamAssignment_1 ) )
+            // InternalOXtype.g:14067:2: ( rule__XSynchronizedExpression__ParamAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); 
+            }
+            // InternalOXtype.g:14068:2: ( rule__XSynchronizedExpression__ParamAssignment_1 )
+            // InternalOXtype.g:14068:3: rule__XSynchronizedExpression__ParamAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__ParamAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getParamAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__2"
+    // InternalOXtype.g:14076:1: rule__XSynchronizedExpression__Group__2 : rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 ;
+    public final void rule__XSynchronizedExpression__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14080:1: ( rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3 )
+            // InternalOXtype.g:14081:2: rule__XSynchronizedExpression__Group__2__Impl rule__XSynchronizedExpression__Group__3
+            {
+            pushFollow(FOLLOW_15);
+            rule__XSynchronizedExpression__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__2"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__2__Impl"
+    // InternalOXtype.g:14088:1: rule__XSynchronizedExpression__Group__2__Impl : ( ')' ) ;
+    public final void rule__XSynchronizedExpression__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14092:1: ( ( ')' ) )
+            // InternalOXtype.g:14093:1: ( ')' )
+            {
+            // InternalOXtype.g:14093:1: ( ')' )
+            // InternalOXtype.g:14094:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__3"
+    // InternalOXtype.g:14103:1: rule__XSynchronizedExpression__Group__3 : rule__XSynchronizedExpression__Group__3__Impl ;
+    public final void rule__XSynchronizedExpression__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14107:1: ( rule__XSynchronizedExpression__Group__3__Impl )
+            // InternalOXtype.g:14108:2: rule__XSynchronizedExpression__Group__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__3"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group__3__Impl"
+    // InternalOXtype.g:14114:1: rule__XSynchronizedExpression__Group__3__Impl : ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) ;
+    public final void rule__XSynchronizedExpression__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14118:1: ( ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) ) )
+            // InternalOXtype.g:14119:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) )
+            {
+            // InternalOXtype.g:14119:1: ( ( rule__XSynchronizedExpression__ExpressionAssignment_3 ) )
+            // InternalOXtype.g:14120:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); 
+            }
+            // InternalOXtype.g:14121:2: ( rule__XSynchronizedExpression__ExpressionAssignment_3 )
+            // InternalOXtype.g:14121:3: rule__XSynchronizedExpression__ExpressionAssignment_3
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__ExpressionAssignment_3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionAssignment_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0__0"
+    // InternalOXtype.g:14130:1: rule__XSynchronizedExpression__Group_0__0 : rule__XSynchronizedExpression__Group_0__0__Impl ;
+    public final void rule__XSynchronizedExpression__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14134:1: ( rule__XSynchronizedExpression__Group_0__0__Impl )
+            // InternalOXtype.g:14135:2: rule__XSynchronizedExpression__Group_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0__0"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0__0__Impl"
+    // InternalOXtype.g:14141:1: rule__XSynchronizedExpression__Group_0__0__Impl : ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) ;
+    public final void rule__XSynchronizedExpression__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14145:1: ( ( ( rule__XSynchronizedExpression__Group_0_0__0 ) ) )
+            // InternalOXtype.g:14146:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) )
+            {
+            // InternalOXtype.g:14146:1: ( ( rule__XSynchronizedExpression__Group_0_0__0 ) )
+            // InternalOXtype.g:14147:2: ( rule__XSynchronizedExpression__Group_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); 
+            }
+            // InternalOXtype.g:14148:2: ( rule__XSynchronizedExpression__Group_0_0__0 )
+            // InternalOXtype.g:14148:3: rule__XSynchronizedExpression__Group_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getGroup_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0"
+    // InternalOXtype.g:14157:1: rule__XSynchronizedExpression__Group_0_0__0 : rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 ;
+    public final void rule__XSynchronizedExpression__Group_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14161:1: ( rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1 )
+            // InternalOXtype.g:14162:2: rule__XSynchronizedExpression__Group_0_0__0__Impl rule__XSynchronizedExpression__Group_0_0__1
+            {
+            pushFollow(FOLLOW_93);
+            rule__XSynchronizedExpression__Group_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__0__Impl"
+    // InternalOXtype.g:14169:1: rule__XSynchronizedExpression__Group_0_0__0__Impl : ( () ) ;
+    public final void rule__XSynchronizedExpression__Group_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14173:1: ( ( () ) )
+            // InternalOXtype.g:14174:1: ( () )
+            {
+            // InternalOXtype.g:14174:1: ( () )
+            // InternalOXtype.g:14175:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); 
+            }
+            // InternalOXtype.g:14176:2: ()
+            // InternalOXtype.g:14176:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1"
+    // InternalOXtype.g:14184:1: rule__XSynchronizedExpression__Group_0_0__1 : rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 ;
+    public final void rule__XSynchronizedExpression__Group_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14188:1: ( rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2 )
+            // InternalOXtype.g:14189:2: rule__XSynchronizedExpression__Group_0_0__1__Impl rule__XSynchronizedExpression__Group_0_0__2
+            {
+            pushFollow(FOLLOW_11);
+            rule__XSynchronizedExpression__Group_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group_0_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__1__Impl"
+    // InternalOXtype.g:14196:1: rule__XSynchronizedExpression__Group_0_0__1__Impl : ( 'synchronized' ) ;
+    public final void rule__XSynchronizedExpression__Group_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14200:1: ( ( 'synchronized' ) )
+            // InternalOXtype.g:14201:1: ( 'synchronized' )
+            {
+            // InternalOXtype.g:14201:1: ( 'synchronized' )
+            // InternalOXtype.g:14202:2: 'synchronized'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); 
+            }
+            match(input,79,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2"
+    // InternalOXtype.g:14211:1: rule__XSynchronizedExpression__Group_0_0__2 : rule__XSynchronizedExpression__Group_0_0__2__Impl ;
+    public final void rule__XSynchronizedExpression__Group_0_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14215:1: ( rule__XSynchronizedExpression__Group_0_0__2__Impl )
+            // InternalOXtype.g:14216:2: rule__XSynchronizedExpression__Group_0_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XSynchronizedExpression__Group_0_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__Group_0_0__2__Impl"
+    // InternalOXtype.g:14222:1: rule__XSynchronizedExpression__Group_0_0__2__Impl : ( '(' ) ;
+    public final void rule__XSynchronizedExpression__Group_0_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14226:1: ( ( '(' ) )
+            // InternalOXtype.g:14227:1: ( '(' )
+            {
+            // InternalOXtype.g:14227:1: ( '(' )
+            // InternalOXtype.g:14228:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__Group_0_0__2__Impl"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__0"
+    // InternalOXtype.g:14238:1: rule__XCatchClause__Group__0 : rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 ;
+    public final void rule__XCatchClause__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14242:1: ( rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1 )
+            // InternalOXtype.g:14243:2: rule__XCatchClause__Group__0__Impl rule__XCatchClause__Group__1
+            {
+            pushFollow(FOLLOW_11);
+            rule__XCatchClause__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__0"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__0__Impl"
+    // InternalOXtype.g:14250:1: rule__XCatchClause__Group__0__Impl : ( ( 'catch' ) ) ;
+    public final void rule__XCatchClause__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14254:1: ( ( ( 'catch' ) ) )
+            // InternalOXtype.g:14255:1: ( ( 'catch' ) )
+            {
+            // InternalOXtype.g:14255:1: ( ( 'catch' ) )
+            // InternalOXtype.g:14256:2: ( 'catch' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); 
+            }
+            // InternalOXtype.g:14257:2: ( 'catch' )
+            // InternalOXtype.g:14257:3: 'catch'
+            {
+            match(input,80,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getCatchKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__1"
+    // InternalOXtype.g:14265:1: rule__XCatchClause__Group__1 : rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 ;
+    public final void rule__XCatchClause__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14269:1: ( rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2 )
+            // InternalOXtype.g:14270:2: rule__XCatchClause__Group__1__Impl rule__XCatchClause__Group__2
+            {
+            pushFollow(FOLLOW_32);
+            rule__XCatchClause__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__1"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__1__Impl"
+    // InternalOXtype.g:14277:1: rule__XCatchClause__Group__1__Impl : ( '(' ) ;
+    public final void rule__XCatchClause__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14281:1: ( ( '(' ) )
+            // InternalOXtype.g:14282:1: ( '(' )
+            {
+            // InternalOXtype.g:14282:1: ( '(' )
+            // InternalOXtype.g:14283:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__2"
+    // InternalOXtype.g:14292:1: rule__XCatchClause__Group__2 : rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 ;
+    public final void rule__XCatchClause__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14296:1: ( rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3 )
+            // InternalOXtype.g:14297:2: rule__XCatchClause__Group__2__Impl rule__XCatchClause__Group__3
+            {
+            pushFollow(FOLLOW_61);
+            rule__XCatchClause__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__Group__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__2"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__2__Impl"
+    // InternalOXtype.g:14304:1: rule__XCatchClause__Group__2__Impl : ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) ;
+    public final void rule__XCatchClause__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14308:1: ( ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) ) )
+            // InternalOXtype.g:14309:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) )
+            {
+            // InternalOXtype.g:14309:1: ( ( rule__XCatchClause__DeclaredParamAssignment_2 ) )
+            // InternalOXtype.g:14310:2: ( rule__XCatchClause__DeclaredParamAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); 
+            }
+            // InternalOXtype.g:14311:2: ( rule__XCatchClause__DeclaredParamAssignment_2 )
+            // InternalOXtype.g:14311:3: rule__XCatchClause__DeclaredParamAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__DeclaredParamAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getDeclaredParamAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__3"
+    // InternalOXtype.g:14319:1: rule__XCatchClause__Group__3 : rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 ;
+    public final void rule__XCatchClause__Group__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14323:1: ( rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4 )
+            // InternalOXtype.g:14324:2: rule__XCatchClause__Group__3__Impl rule__XCatchClause__Group__4
+            {
+            pushFollow(FOLLOW_15);
+            rule__XCatchClause__Group__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__Group__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__3"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__3__Impl"
+    // InternalOXtype.g:14331:1: rule__XCatchClause__Group__3__Impl : ( ')' ) ;
+    public final void rule__XCatchClause__Group__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14335:1: ( ( ')' ) )
+            // InternalOXtype.g:14336:1: ( ')' )
+            {
+            // InternalOXtype.g:14336:1: ( ')' )
+            // InternalOXtype.g:14337:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__3__Impl"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__4"
+    // InternalOXtype.g:14346:1: rule__XCatchClause__Group__4 : rule__XCatchClause__Group__4__Impl ;
+    public final void rule__XCatchClause__Group__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14350:1: ( rule__XCatchClause__Group__4__Impl )
+            // InternalOXtype.g:14351:2: rule__XCatchClause__Group__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__Group__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__4"
+
+
+    // $ANTLR start "rule__XCatchClause__Group__4__Impl"
+    // InternalOXtype.g:14357:1: rule__XCatchClause__Group__4__Impl : ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) ;
+    public final void rule__XCatchClause__Group__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14361:1: ( ( ( rule__XCatchClause__ExpressionAssignment_4 ) ) )
+            // InternalOXtype.g:14362:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) )
+            {
+            // InternalOXtype.g:14362:1: ( ( rule__XCatchClause__ExpressionAssignment_4 ) )
+            // InternalOXtype.g:14363:2: ( rule__XCatchClause__ExpressionAssignment_4 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); 
+            }
+            // InternalOXtype.g:14364:2: ( rule__XCatchClause__ExpressionAssignment_4 )
+            // InternalOXtype.g:14364:3: rule__XCatchClause__ExpressionAssignment_4
+            {
+            pushFollow(FOLLOW_2);
+            rule__XCatchClause__ExpressionAssignment_4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getExpressionAssignment_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__Group__4__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group__0"
+    // InternalOXtype.g:14373:1: rule__QualifiedName__Group__0 : rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 ;
+    public final void rule__QualifiedName__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14377:1: ( rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1 )
+            // InternalOXtype.g:14378:2: rule__QualifiedName__Group__0__Impl rule__QualifiedName__Group__1
+            {
+            pushFollow(FOLLOW_94);
+            rule__QualifiedName__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__QualifiedName__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group__0"
+
+
+    // $ANTLR start "rule__QualifiedName__Group__0__Impl"
+    // InternalOXtype.g:14385:1: rule__QualifiedName__Group__0__Impl : ( ruleValidID ) ;
+    public final void rule__QualifiedName__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14389:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:14390:1: ( ruleValidID )
+            {
+            // InternalOXtype.g:14390:1: ( ruleValidID )
+            // InternalOXtype.g:14391:2: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group__1"
+    // InternalOXtype.g:14400:1: rule__QualifiedName__Group__1 : rule__QualifiedName__Group__1__Impl ;
+    public final void rule__QualifiedName__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14404:1: ( rule__QualifiedName__Group__1__Impl )
+            // InternalOXtype.g:14405:2: rule__QualifiedName__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedName__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group__1"
+
+
+    // $ANTLR start "rule__QualifiedName__Group__1__Impl"
+    // InternalOXtype.g:14411:1: rule__QualifiedName__Group__1__Impl : ( ( rule__QualifiedName__Group_1__0 )* ) ;
+    public final void rule__QualifiedName__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14415:1: ( ( ( rule__QualifiedName__Group_1__0 )* ) )
+            // InternalOXtype.g:14416:1: ( ( rule__QualifiedName__Group_1__0 )* )
+            {
+            // InternalOXtype.g:14416:1: ( ( rule__QualifiedName__Group_1__0 )* )
+            // InternalOXtype.g:14417:2: ( rule__QualifiedName__Group_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:14418:2: ( rule__QualifiedName__Group_1__0 )*
+            loop116:
+            do {
+                int alt116=2;
+                int LA116_0 = input.LA(1);
+
+                if ( (LA116_0==43) ) {
+                    int LA116_2 = input.LA(2);
+
+                    if ( (LA116_2==RULE_ID) ) {
+                        int LA116_3 = input.LA(3);
+
+                        if ( (synpred160_InternalOXtype()) ) {
+                            alt116=1;
+                        }
+
+
+                    }
+
+
+                }
+
+
+                switch (alt116) {
+            	case 1 :
+            	    // InternalOXtype.g:14418:3: rule__QualifiedName__Group_1__0
+            	    {
+            	    pushFollow(FOLLOW_95);
+            	    rule__QualifiedName__Group_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop116;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group__1__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group_1__0"
+    // InternalOXtype.g:14427:1: rule__QualifiedName__Group_1__0 : rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 ;
+    public final void rule__QualifiedName__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14431:1: ( rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1 )
+            // InternalOXtype.g:14432:2: rule__QualifiedName__Group_1__0__Impl rule__QualifiedName__Group_1__1
+            {
+            pushFollow(FOLLOW_9);
+            rule__QualifiedName__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__QualifiedName__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group_1__0"
+
+
+    // $ANTLR start "rule__QualifiedName__Group_1__0__Impl"
+    // InternalOXtype.g:14439:1: rule__QualifiedName__Group_1__0__Impl : ( ( '.' ) ) ;
+    public final void rule__QualifiedName__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14443:1: ( ( ( '.' ) ) )
+            // InternalOXtype.g:14444:1: ( ( '.' ) )
+            {
+            // InternalOXtype.g:14444:1: ( ( '.' ) )
+            // InternalOXtype.g:14445:2: ( '.' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
+            }
+            // InternalOXtype.g:14446:2: ( '.' )
+            // InternalOXtype.g:14446:3: '.'
+            {
+            match(input,43,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedName__Group_1__1"
+    // InternalOXtype.g:14454:1: rule__QualifiedName__Group_1__1 : rule__QualifiedName__Group_1__1__Impl ;
+    public final void rule__QualifiedName__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14458:1: ( rule__QualifiedName__Group_1__1__Impl )
+            // InternalOXtype.g:14459:2: rule__QualifiedName__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedName__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group_1__1"
+
+
+    // $ANTLR start "rule__QualifiedName__Group_1__1__Impl"
+    // InternalOXtype.g:14465:1: rule__QualifiedName__Group_1__1__Impl : ( ruleValidID ) ;
+    public final void rule__QualifiedName__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14469:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:14470:1: ( ruleValidID )
+            {
+            // InternalOXtype.g:14470:1: ( ruleValidID )
+            // InternalOXtype.g:14471:2: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedName__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__Number__Group_1__0"
+    // InternalOXtype.g:14481:1: rule__Number__Group_1__0 : rule__Number__Group_1__0__Impl rule__Number__Group_1__1 ;
+    public final void rule__Number__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14485:1: ( rule__Number__Group_1__0__Impl rule__Number__Group_1__1 )
+            // InternalOXtype.g:14486:2: rule__Number__Group_1__0__Impl rule__Number__Group_1__1
+            {
+            pushFollow(FOLLOW_94);
+            rule__Number__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__Number__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1__0"
+
+
+    // $ANTLR start "rule__Number__Group_1__0__Impl"
+    // InternalOXtype.g:14493:1: rule__Number__Group_1__0__Impl : ( ( rule__Number__Alternatives_1_0 ) ) ;
+    public final void rule__Number__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14497:1: ( ( ( rule__Number__Alternatives_1_0 ) ) )
+            // InternalOXtype.g:14498:1: ( ( rule__Number__Alternatives_1_0 ) )
+            {
+            // InternalOXtype.g:14498:1: ( ( rule__Number__Alternatives_1_0 ) )
+            // InternalOXtype.g:14499:2: ( rule__Number__Alternatives_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getNumberAccess().getAlternatives_1_0()); 
+            }
+            // InternalOXtype.g:14500:2: ( rule__Number__Alternatives_1_0 )
+            // InternalOXtype.g:14500:3: rule__Number__Alternatives_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__Number__Alternatives_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getNumberAccess().getAlternatives_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__Number__Group_1__1"
+    // InternalOXtype.g:14508:1: rule__Number__Group_1__1 : rule__Number__Group_1__1__Impl ;
+    public final void rule__Number__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14512:1: ( rule__Number__Group_1__1__Impl )
+            // InternalOXtype.g:14513:2: rule__Number__Group_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__Number__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1__1"
+
+
+    // $ANTLR start "rule__Number__Group_1__1__Impl"
+    // InternalOXtype.g:14519:1: rule__Number__Group_1__1__Impl : ( ( rule__Number__Group_1_1__0 )? ) ;
+    public final void rule__Number__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14523:1: ( ( ( rule__Number__Group_1_1__0 )? ) )
+            // InternalOXtype.g:14524:1: ( ( rule__Number__Group_1_1__0 )? )
+            {
+            // InternalOXtype.g:14524:1: ( ( rule__Number__Group_1_1__0 )? )
+            // InternalOXtype.g:14525:2: ( rule__Number__Group_1_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getNumberAccess().getGroup_1_1()); 
+            }
+            // InternalOXtype.g:14526:2: ( rule__Number__Group_1_1__0 )?
+            int alt117=2;
+            int LA117_0 = input.LA(1);
+
+            if ( (LA117_0==43) ) {
+                int LA117_1 = input.LA(2);
+
+                if ( ((LA117_1>=RULE_INT && LA117_1<=RULE_DECIMAL)) ) {
+                    alt117=1;
+                }
+            }
+            switch (alt117) {
+                case 1 :
+                    // InternalOXtype.g:14526:3: rule__Number__Group_1_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__Number__Group_1_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getNumberAccess().getGroup_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__Number__Group_1_1__0"
+    // InternalOXtype.g:14535:1: rule__Number__Group_1_1__0 : rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 ;
+    public final void rule__Number__Group_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14539:1: ( rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1 )
+            // InternalOXtype.g:14540:2: rule__Number__Group_1_1__0__Impl rule__Number__Group_1_1__1
+            {
+            pushFollow(FOLLOW_96);
+            rule__Number__Group_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__Number__Group_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1_1__0"
+
+
+    // $ANTLR start "rule__Number__Group_1_1__0__Impl"
+    // InternalOXtype.g:14547:1: rule__Number__Group_1_1__0__Impl : ( '.' ) ;
+    public final void rule__Number__Group_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14551:1: ( ( '.' ) )
+            // InternalOXtype.g:14552:1: ( '.' )
+            {
+            // InternalOXtype.g:14552:1: ( '.' )
+            // InternalOXtype.g:14553:2: '.'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); 
+            }
+            match(input,43,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__Number__Group_1_1__1"
+    // InternalOXtype.g:14562:1: rule__Number__Group_1_1__1 : rule__Number__Group_1_1__1__Impl ;
+    public final void rule__Number__Group_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14566:1: ( rule__Number__Group_1_1__1__Impl )
+            // InternalOXtype.g:14567:2: rule__Number__Group_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__Number__Group_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1_1__1"
+
+
+    // $ANTLR start "rule__Number__Group_1_1__1__Impl"
+    // InternalOXtype.g:14573:1: rule__Number__Group_1_1__1__Impl : ( ( rule__Number__Alternatives_1_1_1 ) ) ;
+    public final void rule__Number__Group_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14577:1: ( ( ( rule__Number__Alternatives_1_1_1 ) ) )
+            // InternalOXtype.g:14578:1: ( ( rule__Number__Alternatives_1_1_1 ) )
+            {
+            // InternalOXtype.g:14578:1: ( ( rule__Number__Alternatives_1_1_1 ) )
+            // InternalOXtype.g:14579:2: ( rule__Number__Alternatives_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); 
+            }
+            // InternalOXtype.g:14580:2: ( rule__Number__Alternatives_1_1_1 )
+            // InternalOXtype.g:14580:3: rule__Number__Alternatives_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__Number__Alternatives_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getNumberAccess().getAlternatives_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__Number__Group_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0__0"
+    // InternalOXtype.g:14589:1: rule__JvmTypeReference__Group_0__0 : rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 ;
+    public final void rule__JvmTypeReference__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14593:1: ( rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1 )
+            // InternalOXtype.g:14594:2: rule__JvmTypeReference__Group_0__0__Impl rule__JvmTypeReference__Group_0__1
+            {
+            pushFollow(FOLLOW_19);
+            rule__JvmTypeReference__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Group_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0__0"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0__0__Impl"
+    // InternalOXtype.g:14601:1: rule__JvmTypeReference__Group_0__0__Impl : ( ruleJvmParameterizedTypeReference ) ;
+    public final void rule__JvmTypeReference__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14605:1: ( ( ruleJvmParameterizedTypeReference ) )
+            // InternalOXtype.g:14606:1: ( ruleJvmParameterizedTypeReference )
+            {
+            // InternalOXtype.g:14606:1: ( ruleJvmParameterizedTypeReference )
+            // InternalOXtype.g:14607:2: ruleJvmParameterizedTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmParameterizedTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0__1"
+    // InternalOXtype.g:14616:1: rule__JvmTypeReference__Group_0__1 : rule__JvmTypeReference__Group_0__1__Impl ;
+    public final void rule__JvmTypeReference__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14620:1: ( rule__JvmTypeReference__Group_0__1__Impl )
+            // InternalOXtype.g:14621:2: rule__JvmTypeReference__Group_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Group_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0__1"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0__1__Impl"
+    // InternalOXtype.g:14627:1: rule__JvmTypeReference__Group_0__1__Impl : ( ( rule__JvmTypeReference__Group_0_1__0 )* ) ;
+    public final void rule__JvmTypeReference__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14631:1: ( ( ( rule__JvmTypeReference__Group_0_1__0 )* ) )
+            // InternalOXtype.g:14632:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* )
+            {
+            // InternalOXtype.g:14632:1: ( ( rule__JvmTypeReference__Group_0_1__0 )* )
+            // InternalOXtype.g:14633:2: ( rule__JvmTypeReference__Group_0_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); 
+            }
+            // InternalOXtype.g:14634:2: ( rule__JvmTypeReference__Group_0_1__0 )*
+            loop118:
+            do {
+                int alt118=2;
+                int LA118_0 = input.LA(1);
+
+                if ( (LA118_0==58) ) {
+                    int LA118_2 = input.LA(2);
+
+                    if ( (LA118_2==56) ) {
+                        int LA118_3 = input.LA(3);
+
+                        if ( (synpred162_InternalOXtype()) ) {
+                            alt118=1;
+                        }
+
+
+                    }
+
+
+                }
+
+
+                switch (alt118) {
+            	case 1 :
+            	    // InternalOXtype.g:14634:3: rule__JvmTypeReference__Group_0_1__0
+            	    {
+            	    pushFollow(FOLLOW_86);
+            	    rule__JvmTypeReference__Group_0_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop118;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0__1__Impl"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0_1__0"
+    // InternalOXtype.g:14643:1: rule__JvmTypeReference__Group_0_1__0 : rule__JvmTypeReference__Group_0_1__0__Impl ;
+    public final void rule__JvmTypeReference__Group_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14647:1: ( rule__JvmTypeReference__Group_0_1__0__Impl )
+            // InternalOXtype.g:14648:2: rule__JvmTypeReference__Group_0_1__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Group_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0_1__0"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0_1__0__Impl"
+    // InternalOXtype.g:14654:1: rule__JvmTypeReference__Group_0_1__0__Impl : ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) ;
+    public final void rule__JvmTypeReference__Group_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14658:1: ( ( ( rule__JvmTypeReference__Group_0_1_0__0 ) ) )
+            // InternalOXtype.g:14659:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) )
+            {
+            // InternalOXtype.g:14659:1: ( ( rule__JvmTypeReference__Group_0_1_0__0 ) )
+            // InternalOXtype.g:14660:2: ( rule__JvmTypeReference__Group_0_1_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); 
+            }
+            // InternalOXtype.g:14661:2: ( rule__JvmTypeReference__Group_0_1_0__0 )
+            // InternalOXtype.g:14661:3: rule__JvmTypeReference__Group_0_1_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Group_0_1_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceAccess().getGroup_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0"
+    // InternalOXtype.g:14670:1: rule__JvmTypeReference__Group_0_1_0__0 : rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 ;
+    public final void rule__JvmTypeReference__Group_0_1_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14674:1: ( rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1 )
+            // InternalOXtype.g:14675:2: rule__JvmTypeReference__Group_0_1_0__0__Impl rule__JvmTypeReference__Group_0_1_0__1
+            {
+            pushFollow(FOLLOW_19);
+            rule__JvmTypeReference__Group_0_1_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Group_0_1_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__0__Impl"
+    // InternalOXtype.g:14682:1: rule__JvmTypeReference__Group_0_1_0__0__Impl : ( () ) ;
+    public final void rule__JvmTypeReference__Group_0_1_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14686:1: ( ( () ) )
+            // InternalOXtype.g:14687:1: ( () )
+            {
+            // InternalOXtype.g:14687:1: ( () )
+            // InternalOXtype.g:14688:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); 
+            }
+            // InternalOXtype.g:14689:2: ()
+            // InternalOXtype.g:14689:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__0__Impl"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1"
+    // InternalOXtype.g:14697:1: rule__JvmTypeReference__Group_0_1_0__1 : rule__JvmTypeReference__Group_0_1_0__1__Impl ;
+    public final void rule__JvmTypeReference__Group_0_1_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14701:1: ( rule__JvmTypeReference__Group_0_1_0__1__Impl )
+            // InternalOXtype.g:14702:2: rule__JvmTypeReference__Group_0_1_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmTypeReference__Group_0_1_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1"
+
+
+    // $ANTLR start "rule__JvmTypeReference__Group_0_1_0__1__Impl"
+    // InternalOXtype.g:14708:1: rule__JvmTypeReference__Group_0_1_0__1__Impl : ( ruleArrayBrackets ) ;
+    public final void rule__JvmTypeReference__Group_0_1_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14712:1: ( ( ruleArrayBrackets ) )
+            // InternalOXtype.g:14713:1: ( ruleArrayBrackets )
+            {
+            // InternalOXtype.g:14713:1: ( ruleArrayBrackets )
+            // InternalOXtype.g:14714:2: ruleArrayBrackets
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleArrayBrackets();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmTypeReference__Group_0_1_0__1__Impl"
+
+
+    // $ANTLR start "rule__ArrayBrackets__Group__0"
+    // InternalOXtype.g:14724:1: rule__ArrayBrackets__Group__0 : rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 ;
+    public final void rule__ArrayBrackets__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14728:1: ( rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1 )
+            // InternalOXtype.g:14729:2: rule__ArrayBrackets__Group__0__Impl rule__ArrayBrackets__Group__1
+            {
+            pushFollow(FOLLOW_58);
+            rule__ArrayBrackets__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__ArrayBrackets__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ArrayBrackets__Group__0"
+
+
+    // $ANTLR start "rule__ArrayBrackets__Group__0__Impl"
+    // InternalOXtype.g:14736:1: rule__ArrayBrackets__Group__0__Impl : ( '[' ) ;
+    public final void rule__ArrayBrackets__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14740:1: ( ( '[' ) )
+            // InternalOXtype.g:14741:1: ( '[' )
+            {
+            // InternalOXtype.g:14741:1: ( '[' )
+            // InternalOXtype.g:14742:2: '['
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); 
+            }
+            match(input,58,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ArrayBrackets__Group__0__Impl"
+
+
+    // $ANTLR start "rule__ArrayBrackets__Group__1"
+    // InternalOXtype.g:14751:1: rule__ArrayBrackets__Group__1 : rule__ArrayBrackets__Group__1__Impl ;
+    public final void rule__ArrayBrackets__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14755:1: ( rule__ArrayBrackets__Group__1__Impl )
+            // InternalOXtype.g:14756:2: rule__ArrayBrackets__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__ArrayBrackets__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ArrayBrackets__Group__1"
+
+
+    // $ANTLR start "rule__ArrayBrackets__Group__1__Impl"
+    // InternalOXtype.g:14762:1: rule__ArrayBrackets__Group__1__Impl : ( ']' ) ;
+    public final void rule__ArrayBrackets__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14766:1: ( ( ']' ) )
+            // InternalOXtype.g:14767:1: ( ']' )
+            {
+            // InternalOXtype.g:14767:1: ( ']' )
+            // InternalOXtype.g:14768:2: ']'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); 
+            }
+            match(input,56,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__ArrayBrackets__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group__0"
+    // InternalOXtype.g:14778:1: rule__XFunctionTypeRef__Group__0 : rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 ;
+    public final void rule__XFunctionTypeRef__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14782:1: ( rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1 )
+            // InternalOXtype.g:14783:2: rule__XFunctionTypeRef__Group__0__Impl rule__XFunctionTypeRef__Group__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XFunctionTypeRef__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group__0"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group__0__Impl"
+    // InternalOXtype.g:14790:1: rule__XFunctionTypeRef__Group__0__Impl : ( ( rule__XFunctionTypeRef__Group_0__0 )? ) ;
+    public final void rule__XFunctionTypeRef__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14794:1: ( ( ( rule__XFunctionTypeRef__Group_0__0 )? ) )
+            // InternalOXtype.g:14795:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? )
+            {
+            // InternalOXtype.g:14795:1: ( ( rule__XFunctionTypeRef__Group_0__0 )? )
+            // InternalOXtype.g:14796:2: ( rule__XFunctionTypeRef__Group_0__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); 
+            }
+            // InternalOXtype.g:14797:2: ( rule__XFunctionTypeRef__Group_0__0 )?
+            int alt119=2;
+            int LA119_0 = input.LA(1);
+
+            if ( (LA119_0==53) ) {
+                alt119=1;
+            }
+            switch (alt119) {
+                case 1 :
+                    // InternalOXtype.g:14797:3: rule__XFunctionTypeRef__Group_0__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFunctionTypeRef__Group_0__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group__0__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group__1"
+    // InternalOXtype.g:14805:1: rule__XFunctionTypeRef__Group__1 : rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 ;
+    public final void rule__XFunctionTypeRef__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14809:1: ( rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2 )
+            // InternalOXtype.g:14810:2: rule__XFunctionTypeRef__Group__1__Impl rule__XFunctionTypeRef__Group__2
+            {
+            pushFollow(FOLLOW_32);
+            rule__XFunctionTypeRef__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group__1"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group__1__Impl"
+    // InternalOXtype.g:14817:1: rule__XFunctionTypeRef__Group__1__Impl : ( '=>' ) ;
+    public final void rule__XFunctionTypeRef__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14821:1: ( ( '=>' ) )
+            // InternalOXtype.g:14822:1: ( '=>' )
+            {
+            // InternalOXtype.g:14822:1: ( '=>' )
+            // InternalOXtype.g:14823:2: '=>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); 
+            }
+            match(input,31,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group__2"
+    // InternalOXtype.g:14832:1: rule__XFunctionTypeRef__Group__2 : rule__XFunctionTypeRef__Group__2__Impl ;
+    public final void rule__XFunctionTypeRef__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14836:1: ( rule__XFunctionTypeRef__Group__2__Impl )
+            // InternalOXtype.g:14837:2: rule__XFunctionTypeRef__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group__2"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group__2__Impl"
+    // InternalOXtype.g:14843:1: rule__XFunctionTypeRef__Group__2__Impl : ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) ;
+    public final void rule__XFunctionTypeRef__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14847:1: ( ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) ) )
+            // InternalOXtype.g:14848:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) )
+            {
+            // InternalOXtype.g:14848:1: ( ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 ) )
+            // InternalOXtype.g:14849:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); 
+            }
+            // InternalOXtype.g:14850:2: ( rule__XFunctionTypeRef__ReturnTypeAssignment_2 )
+            // InternalOXtype.g:14850:3: rule__XFunctionTypeRef__ReturnTypeAssignment_2
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__ReturnTypeAssignment_2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeAssignment_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group__2__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0__0"
+    // InternalOXtype.g:14859:1: rule__XFunctionTypeRef__Group_0__0 : rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 ;
+    public final void rule__XFunctionTypeRef__Group_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14863:1: ( rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1 )
+            // InternalOXtype.g:14864:2: rule__XFunctionTypeRef__Group_0__0__Impl rule__XFunctionTypeRef__Group_0__1
+            {
+            pushFollow(FOLLOW_97);
+            rule__XFunctionTypeRef__Group_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0__0"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0__0__Impl"
+    // InternalOXtype.g:14871:1: rule__XFunctionTypeRef__Group_0__0__Impl : ( '(' ) ;
+    public final void rule__XFunctionTypeRef__Group_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14875:1: ( ( '(' ) )
+            // InternalOXtype.g:14876:1: ( '(' )
+            {
+            // InternalOXtype.g:14876:1: ( '(' )
+            // InternalOXtype.g:14877:2: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0__0__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0__1"
+    // InternalOXtype.g:14886:1: rule__XFunctionTypeRef__Group_0__1 : rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 ;
+    public final void rule__XFunctionTypeRef__Group_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14890:1: ( rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2 )
+            // InternalOXtype.g:14891:2: rule__XFunctionTypeRef__Group_0__1__Impl rule__XFunctionTypeRef__Group_0__2
+            {
+            pushFollow(FOLLOW_97);
+            rule__XFunctionTypeRef__Group_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0__1"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0__1__Impl"
+    // InternalOXtype.g:14898:1: rule__XFunctionTypeRef__Group_0__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) ;
+    public final void rule__XFunctionTypeRef__Group_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14902:1: ( ( ( rule__XFunctionTypeRef__Group_0_1__0 )? ) )
+            // InternalOXtype.g:14903:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? )
+            {
+            // InternalOXtype.g:14903:1: ( ( rule__XFunctionTypeRef__Group_0_1__0 )? )
+            // InternalOXtype.g:14904:2: ( rule__XFunctionTypeRef__Group_0_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); 
+            }
+            // InternalOXtype.g:14905:2: ( rule__XFunctionTypeRef__Group_0_1__0 )?
+            int alt120=2;
+            int LA120_0 = input.LA(1);
+
+            if ( (LA120_0==RULE_ID||LA120_0==31||LA120_0==53) ) {
+                alt120=1;
+            }
+            switch (alt120) {
+                case 1 :
+                    // InternalOXtype.g:14905:3: rule__XFunctionTypeRef__Group_0_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__XFunctionTypeRef__Group_0_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0__1__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0__2"
+    // InternalOXtype.g:14913:1: rule__XFunctionTypeRef__Group_0__2 : rule__XFunctionTypeRef__Group_0__2__Impl ;
+    public final void rule__XFunctionTypeRef__Group_0__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14917:1: ( rule__XFunctionTypeRef__Group_0__2__Impl )
+            // InternalOXtype.g:14918:2: rule__XFunctionTypeRef__Group_0__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0__2"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0__2__Impl"
+    // InternalOXtype.g:14924:1: rule__XFunctionTypeRef__Group_0__2__Impl : ( ')' ) ;
+    public final void rule__XFunctionTypeRef__Group_0__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14928:1: ( ( ')' ) )
+            // InternalOXtype.g:14929:1: ( ')' )
+            {
+            // InternalOXtype.g:14929:1: ( ')' )
+            // InternalOXtype.g:14930:2: ')'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); 
+            }
+            match(input,54,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0__2__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0"
+    // InternalOXtype.g:14940:1: rule__XFunctionTypeRef__Group_0_1__0 : rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 ;
+    public final void rule__XFunctionTypeRef__Group_0_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14944:1: ( rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1 )
+            // InternalOXtype.g:14945:2: rule__XFunctionTypeRef__Group_0_1__0__Impl rule__XFunctionTypeRef__Group_0_1__1
+            {
+            pushFollow(FOLLOW_13);
+            rule__XFunctionTypeRef__Group_0_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__0__Impl"
+    // InternalOXtype.g:14952:1: rule__XFunctionTypeRef__Group_0_1__0__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) ;
+    public final void rule__XFunctionTypeRef__Group_0_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14956:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) ) )
+            // InternalOXtype.g:14957:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) )
+            {
+            // InternalOXtype.g:14957:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 ) )
+            // InternalOXtype.g:14958:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); 
+            }
+            // InternalOXtype.g:14959:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 )
+            // InternalOXtype.g:14959:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__0__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1"
+    // InternalOXtype.g:14967:1: rule__XFunctionTypeRef__Group_0_1__1 : rule__XFunctionTypeRef__Group_0_1__1__Impl ;
+    public final void rule__XFunctionTypeRef__Group_0_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14971:1: ( rule__XFunctionTypeRef__Group_0_1__1__Impl )
+            // InternalOXtype.g:14972:2: rule__XFunctionTypeRef__Group_0_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1__1__Impl"
+    // InternalOXtype.g:14978:1: rule__XFunctionTypeRef__Group_0_1__1__Impl : ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) ;
+    public final void rule__XFunctionTypeRef__Group_0_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14982:1: ( ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* ) )
+            // InternalOXtype.g:14983:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* )
+            {
+            // InternalOXtype.g:14983:1: ( ( rule__XFunctionTypeRef__Group_0_1_1__0 )* )
+            // InternalOXtype.g:14984:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); 
+            }
+            // InternalOXtype.g:14985:2: ( rule__XFunctionTypeRef__Group_0_1_1__0 )*
+            loop121:
+            do {
+                int alt121=2;
+                int LA121_0 = input.LA(1);
+
+                if ( (LA121_0==55) ) {
+                    alt121=1;
+                }
+
+
+                switch (alt121) {
+            	case 1 :
+            	    // InternalOXtype.g:14985:3: rule__XFunctionTypeRef__Group_0_1_1__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__XFunctionTypeRef__Group_0_1_1__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop121;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getGroup_0_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1__1__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0"
+    // InternalOXtype.g:14994:1: rule__XFunctionTypeRef__Group_0_1_1__0 : rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 ;
+    public final void rule__XFunctionTypeRef__Group_0_1_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:14998:1: ( rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1 )
+            // InternalOXtype.g:14999:2: rule__XFunctionTypeRef__Group_0_1_1__0__Impl rule__XFunctionTypeRef__Group_0_1_1__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__XFunctionTypeRef__Group_0_1_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0_1_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__0__Impl"
+    // InternalOXtype.g:15006:1: rule__XFunctionTypeRef__Group_0_1_1__0__Impl : ( ',' ) ;
+    public final void rule__XFunctionTypeRef__Group_0_1_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15010:1: ( ( ',' ) )
+            // InternalOXtype.g:15011:1: ( ',' )
+            {
+            // InternalOXtype.g:15011:1: ( ',' )
+            // InternalOXtype.g:15012:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__0__Impl"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1"
+    // InternalOXtype.g:15021:1: rule__XFunctionTypeRef__Group_0_1_1__1 : rule__XFunctionTypeRef__Group_0_1_1__1__Impl ;
+    public final void rule__XFunctionTypeRef__Group_0_1_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15025:1: ( rule__XFunctionTypeRef__Group_0_1_1__1__Impl )
+            // InternalOXtype.g:15026:2: rule__XFunctionTypeRef__Group_0_1_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__Group_0_1_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__Group_0_1_1__1__Impl"
+    // InternalOXtype.g:15032:1: rule__XFunctionTypeRef__Group_0_1_1__1__Impl : ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) ;
+    public final void rule__XFunctionTypeRef__Group_0_1_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15036:1: ( ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) ) )
+            // InternalOXtype.g:15037:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) )
+            {
+            // InternalOXtype.g:15037:1: ( ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 ) )
+            // InternalOXtype.g:15038:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); 
+            }
+            // InternalOXtype.g:15039:2: ( rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 )
+            // InternalOXtype.g:15039:3: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesAssignment_0_1_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__Group_0_1_1__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0"
+    // InternalOXtype.g:15048:1: rule__JvmParameterizedTypeReference__Group__0 : rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15052:1: ( rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1 )
+            // InternalOXtype.g:15053:2: rule__JvmParameterizedTypeReference__Group__0__Impl rule__JvmParameterizedTypeReference__Group__1
+            {
+            pushFollow(FOLLOW_22);
+            rule__JvmParameterizedTypeReference__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group__0__Impl"
+    // InternalOXtype.g:15060:1: rule__JvmParameterizedTypeReference__Group__0__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15064:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) ) )
+            // InternalOXtype.g:15065:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) )
+            {
+            // InternalOXtype.g:15065:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_0 ) )
+            // InternalOXtype.g:15066:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); 
+            }
+            // InternalOXtype.g:15067:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_0 )
+            // InternalOXtype.g:15067:3: rule__JvmParameterizedTypeReference__TypeAssignment_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__TypeAssignment_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1"
+    // InternalOXtype.g:15075:1: rule__JvmParameterizedTypeReference__Group__1 : rule__JvmParameterizedTypeReference__Group__1__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15079:1: ( rule__JvmParameterizedTypeReference__Group__1__Impl )
+            // InternalOXtype.g:15080:2: rule__JvmParameterizedTypeReference__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group__1__Impl"
+    // InternalOXtype.g:15086:1: rule__JvmParameterizedTypeReference__Group__1__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) ;
+    public final void rule__JvmParameterizedTypeReference__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15090:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? ) )
+            // InternalOXtype.g:15091:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? )
+            {
+            // InternalOXtype.g:15091:1: ( ( rule__JvmParameterizedTypeReference__Group_1__0 )? )
+            // InternalOXtype.g:15092:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); 
+            }
+            // InternalOXtype.g:15093:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?
+            int alt122=2;
+            alt122 = dfa122.predict(input);
+            switch (alt122) {
+                case 1 :
+                    // InternalOXtype.g:15093:3: rule__JvmParameterizedTypeReference__Group_1__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmParameterizedTypeReference__Group_1__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0"
+    // InternalOXtype.g:15102:1: rule__JvmParameterizedTypeReference__Group_1__0 : rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15106:1: ( rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1 )
+            // InternalOXtype.g:15107:2: rule__JvmParameterizedTypeReference__Group_1__0__Impl rule__JvmParameterizedTypeReference__Group_1__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__JvmParameterizedTypeReference__Group_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__0__Impl"
+    // InternalOXtype.g:15114:1: rule__JvmParameterizedTypeReference__Group_1__0__Impl : ( ( '<' ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15118:1: ( ( ( '<' ) ) )
+            // InternalOXtype.g:15119:1: ( ( '<' ) )
+            {
+            // InternalOXtype.g:15119:1: ( ( '<' ) )
+            // InternalOXtype.g:15120:2: ( '<' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); 
+            }
+            // InternalOXtype.g:15121:2: ( '<' )
+            // InternalOXtype.g:15121:3: '<'
+            {
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1"
+    // InternalOXtype.g:15129:1: rule__JvmParameterizedTypeReference__Group_1__1 : rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15133:1: ( rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2 )
+            // InternalOXtype.g:15134:2: rule__JvmParameterizedTypeReference__Group_1__1__Impl rule__JvmParameterizedTypeReference__Group_1__2
+            {
+            pushFollow(FOLLOW_53);
+            rule__JvmParameterizedTypeReference__Group_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__1__Impl"
+    // InternalOXtype.g:15141:1: rule__JvmParameterizedTypeReference__Group_1__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15145:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) ) )
+            // InternalOXtype.g:15146:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) )
+            {
+            // InternalOXtype.g:15146:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 ) )
+            // InternalOXtype.g:15147:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); 
+            }
+            // InternalOXtype.g:15148:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 )
+            // InternalOXtype.g:15148:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2"
+    // InternalOXtype.g:15156:1: rule__JvmParameterizedTypeReference__Group_1__2 : rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15160:1: ( rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3 )
+            // InternalOXtype.g:15161:2: rule__JvmParameterizedTypeReference__Group_1__2__Impl rule__JvmParameterizedTypeReference__Group_1__3
+            {
+            pushFollow(FOLLOW_53);
+            rule__JvmParameterizedTypeReference__Group_1__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__2__Impl"
+    // InternalOXtype.g:15168:1: rule__JvmParameterizedTypeReference__Group_1__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15172:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* ) )
+            // InternalOXtype.g:15173:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* )
+            {
+            // InternalOXtype.g:15173:1: ( ( rule__JvmParameterizedTypeReference__Group_1_2__0 )* )
+            // InternalOXtype.g:15174:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); 
+            }
+            // InternalOXtype.g:15175:2: ( rule__JvmParameterizedTypeReference__Group_1_2__0 )*
+            loop123:
+            do {
+                int alt123=2;
+                int LA123_0 = input.LA(1);
+
+                if ( (LA123_0==55) ) {
+                    alt123=1;
+                }
+
+
+                switch (alt123) {
+            	case 1 :
+            	    // InternalOXtype.g:15175:3: rule__JvmParameterizedTypeReference__Group_1_2__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__JvmParameterizedTypeReference__Group_1_2__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop123;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__2__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3"
+    // InternalOXtype.g:15183:1: rule__JvmParameterizedTypeReference__Group_1__3 : rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15187:1: ( rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4 )
+            // InternalOXtype.g:15188:2: rule__JvmParameterizedTypeReference__Group_1__3__Impl rule__JvmParameterizedTypeReference__Group_1__4
+            {
+            pushFollow(FOLLOW_94);
+            rule__JvmParameterizedTypeReference__Group_1__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1__4();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__3__Impl"
+    // InternalOXtype.g:15195:1: rule__JvmParameterizedTypeReference__Group_1__3__Impl : ( '>' ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15199:1: ( ( '>' ) )
+            // InternalOXtype.g:15200:1: ( '>' )
+            {
+            // InternalOXtype.g:15200:1: ( '>' )
+            // InternalOXtype.g:15201:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__3__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4"
+    // InternalOXtype.g:15210:1: rule__JvmParameterizedTypeReference__Group_1__4 : rule__JvmParameterizedTypeReference__Group_1__4__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15214:1: ( rule__JvmParameterizedTypeReference__Group_1__4__Impl )
+            // InternalOXtype.g:15215:2: rule__JvmParameterizedTypeReference__Group_1__4__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1__4__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1__4__Impl"
+    // InternalOXtype.g:15221:1: rule__JvmParameterizedTypeReference__Group_1__4__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1__4__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15225:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* ) )
+            // InternalOXtype.g:15226:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* )
+            {
+            // InternalOXtype.g:15226:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4__0 )* )
+            // InternalOXtype.g:15227:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); 
+            }
+            // InternalOXtype.g:15228:2: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )*
+            loop124:
+            do {
+                int alt124=2;
+                int LA124_0 = input.LA(1);
+
+                if ( (LA124_0==43) ) {
+                    int LA124_2 = input.LA(2);
+
+                    if ( (LA124_2==RULE_ID) ) {
+                        int LA124_3 = input.LA(3);
+
+                        if ( (synpred168_InternalOXtype()) ) {
+                            alt124=1;
+                        }
+
+
+                    }
+
+
+                }
+
+
+                switch (alt124) {
+            	case 1 :
+            	    // InternalOXtype.g:15228:3: rule__JvmParameterizedTypeReference__Group_1_4__0
+            	    {
+            	    pushFollow(FOLLOW_95);
+            	    rule__JvmParameterizedTypeReference__Group_1_4__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop124;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1__4__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0"
+    // InternalOXtype.g:15237:1: rule__JvmParameterizedTypeReference__Group_1_2__0 : rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15241:1: ( rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1 )
+            // InternalOXtype.g:15242:2: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_2__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__JvmParameterizedTypeReference__Group_1_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl"
+    // InternalOXtype.g:15249:1: rule__JvmParameterizedTypeReference__Group_1_2__0__Impl : ( ',' ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15253:1: ( ( ',' ) )
+            // InternalOXtype.g:15254:1: ( ',' )
+            {
+            // InternalOXtype.g:15254:1: ( ',' )
+            // InternalOXtype.g:15255:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1"
+    // InternalOXtype.g:15264:1: rule__JvmParameterizedTypeReference__Group_1_2__1 : rule__JvmParameterizedTypeReference__Group_1_2__1__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15268:1: ( rule__JvmParameterizedTypeReference__Group_1_2__1__Impl )
+            // InternalOXtype.g:15269:2: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl"
+    // InternalOXtype.g:15275:1: rule__JvmParameterizedTypeReference__Group_1_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15279:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) ) )
+            // InternalOXtype.g:15280:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) )
+            {
+            // InternalOXtype.g:15280:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 ) )
+            // InternalOXtype.g:15281:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); 
+            }
+            // InternalOXtype.g:15282:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 )
+            // InternalOXtype.g:15282:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_2__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0"
+    // InternalOXtype.g:15291:1: rule__JvmParameterizedTypeReference__Group_1_4__0 : rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15295:1: ( rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1 )
+            // InternalOXtype.g:15296:2: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl rule__JvmParameterizedTypeReference__Group_1_4__1
+            {
+            pushFollow(FOLLOW_9);
+            rule__JvmParameterizedTypeReference__Group_1_4__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl"
+    // InternalOXtype.g:15303:1: rule__JvmParameterizedTypeReference__Group_1_4__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15307:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) ) )
+            // InternalOXtype.g:15308:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) )
+            {
+            // InternalOXtype.g:15308:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 ) )
+            // InternalOXtype.g:15309:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); 
+            }
+            // InternalOXtype.g:15310:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0 )
+            // InternalOXtype.g:15310:3: rule__JvmParameterizedTypeReference__Group_1_4_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1"
+    // InternalOXtype.g:15318:1: rule__JvmParameterizedTypeReference__Group_1_4__1 : rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15322:1: ( rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2 )
+            // InternalOXtype.g:15323:2: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl rule__JvmParameterizedTypeReference__Group_1_4__2
+            {
+            pushFollow(FOLLOW_22);
+            rule__JvmParameterizedTypeReference__Group_1_4__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl"
+    // InternalOXtype.g:15330:1: rule__JvmParameterizedTypeReference__Group_1_4__1__Impl : ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15334:1: ( ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) ) )
+            // InternalOXtype.g:15335:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) )
+            {
+            // InternalOXtype.g:15335:1: ( ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 ) )
+            // InternalOXtype.g:15336:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); 
+            }
+            // InternalOXtype.g:15337:2: ( rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 )
+            // InternalOXtype.g:15337:3: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeAssignment_1_4_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2"
+    // InternalOXtype.g:15345:1: rule__JvmParameterizedTypeReference__Group_1_4__2 : rule__JvmParameterizedTypeReference__Group_1_4__2__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15349:1: ( rule__JvmParameterizedTypeReference__Group_1_4__2__Impl )
+            // InternalOXtype.g:15350:2: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl"
+    // InternalOXtype.g:15356:1: rule__JvmParameterizedTypeReference__Group_1_4__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15360:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? ) )
+            // InternalOXtype.g:15361:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? )
+            {
+            // InternalOXtype.g:15361:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )? )
+            // InternalOXtype.g:15362:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); 
+            }
+            // InternalOXtype.g:15363:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?
+            int alt125=2;
+            alt125 = dfa125.predict(input);
+            switch (alt125) {
+                case 1 :
+                    // InternalOXtype.g:15363:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmParameterizedTypeReference__Group_1_4_2__0();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4__2__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0"
+    // InternalOXtype.g:15372:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15376:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl )
+            // InternalOXtype.g:15377:2: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl"
+    // InternalOXtype.g:15383:1: rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15387:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) ) )
+            // InternalOXtype.g:15388:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) )
+            {
+            // InternalOXtype.g:15388:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 ) )
+            // InternalOXtype.g:15389:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); 
+            }
+            // InternalOXtype.g:15390:2: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 )
+            // InternalOXtype.g:15390:3: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_0_0__0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"
+    // InternalOXtype.g:15399:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15403:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 )
+            // InternalOXtype.g:15404:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_0_0__1
+            {
+            pushFollow(FOLLOW_94);
+            rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_0_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl"
+    // InternalOXtype.g:15411:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl : ( () ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15415:1: ( ( () ) )
+            // InternalOXtype.g:15416:1: ( () )
+            {
+            // InternalOXtype.g:15416:1: ( () )
+            // InternalOXtype.g:15417:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); 
+            }
+            // InternalOXtype.g:15418:2: ()
+            // InternalOXtype.g:15418:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1"
+    // InternalOXtype.g:15426:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1 : rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15430:1: ( rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl )
+            // InternalOXtype.g:15431:2: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl"
+    // InternalOXtype.g:15437:1: rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl : ( '.' ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15441:1: ( ( '.' ) )
+            // InternalOXtype.g:15442:1: ( '.' )
+            {
+            // InternalOXtype.g:15442:1: ( '.' )
+            // InternalOXtype.g:15443:2: '.'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); 
+            }
+            match(input,43,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_0_0__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0"
+    // InternalOXtype.g:15453:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15457:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1 )
+            // InternalOXtype.g:15458:2: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl"
+    // InternalOXtype.g:15465:1: rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl : ( ( '<' ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15469:1: ( ( ( '<' ) ) )
+            // InternalOXtype.g:15470:1: ( ( '<' ) )
+            {
+            // InternalOXtype.g:15470:1: ( ( '<' ) )
+            // InternalOXtype.g:15471:2: ( '<' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); 
+            }
+            // InternalOXtype.g:15472:2: ( '<' )
+            // InternalOXtype.g:15472:3: '<'
+            {
+            match(input,27,FOLLOW_2); if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1"
+    // InternalOXtype.g:15480:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15484:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2 )
+            // InternalOXtype.g:15485:2: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__2
+            {
+            pushFollow(FOLLOW_53);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl"
+    // InternalOXtype.g:15492:1: rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15496:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) ) )
+            // InternalOXtype.g:15497:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) )
+            {
+            // InternalOXtype.g:15497:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 ) )
+            // InternalOXtype.g:15498:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); 
+            }
+            // InternalOXtype.g:15499:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 )
+            // InternalOXtype.g:15499:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__1__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2"
+    // InternalOXtype.g:15507:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2 : rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15511:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3 )
+            // InternalOXtype.g:15512:2: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl rule__JvmParameterizedTypeReference__Group_1_4_2__3
+            {
+            pushFollow(FOLLOW_53);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__3();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl"
+    // InternalOXtype.g:15519:1: rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl : ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15523:1: ( ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* ) )
+            // InternalOXtype.g:15524:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* )
+            {
+            // InternalOXtype.g:15524:1: ( ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )* )
+            // InternalOXtype.g:15525:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); 
+            }
+            // InternalOXtype.g:15526:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 )*
+            loop126:
+            do {
+                int alt126=2;
+                int LA126_0 = input.LA(1);
+
+                if ( (LA126_0==55) ) {
+                    alt126=1;
+                }
+
+
+                switch (alt126) {
+            	case 1 :
+            	    // InternalOXtype.g:15526:3: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0
+            	    {
+            	    pushFollow(FOLLOW_14);
+            	    rule__JvmParameterizedTypeReference__Group_1_4_2_2__0();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop126;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup_1_4_2_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__2__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3"
+    // InternalOXtype.g:15534:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3 : rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15538:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl )
+            // InternalOXtype.g:15539:2: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl"
+    // InternalOXtype.g:15545:1: rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl : ( '>' ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15549:1: ( ( '>' ) )
+            // InternalOXtype.g:15550:1: ( '>' )
+            {
+            // InternalOXtype.g:15550:1: ( '>' )
+            // InternalOXtype.g:15551:2: '>'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); 
+            }
+            match(input,26,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2__3__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"
+    // InternalOXtype.g:15561:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15565:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 )
+            // InternalOXtype.g:15566:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl rule__JvmParameterizedTypeReference__Group_1_4_2_2__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_2_2__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl"
+    // InternalOXtype.g:15573:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl : ( ',' ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15577:1: ( ( ',' ) )
+            // InternalOXtype.g:15578:1: ( ',' )
+            {
+            // InternalOXtype.g:15578:1: ( ',' )
+            // InternalOXtype.g:15579:2: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__0__Impl"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1"
+    // InternalOXtype.g:15588:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1 : rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15592:1: ( rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl )
+            // InternalOXtype.g:15593:2: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl"
+    // InternalOXtype.g:15599:1: rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl : ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) ;
+    public final void rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15603:1: ( ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) ) )
+            // InternalOXtype.g:15604:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) )
+            {
+            // InternalOXtype.g:15604:1: ( ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 ) )
+            // InternalOXtype.g:15605:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); 
+            }
+            // InternalOXtype.g:15606:2: ( rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 )
+            // InternalOXtype.g:15606:3: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsAssignment_1_4_2_2_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__Group_1_4_2_2__1__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group__0"
+    // InternalOXtype.g:15615:1: rule__JvmWildcardTypeReference__Group__0 : rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 ;
+    public final void rule__JvmWildcardTypeReference__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15619:1: ( rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1 )
+            // InternalOXtype.g:15620:2: rule__JvmWildcardTypeReference__Group__0__Impl rule__JvmWildcardTypeReference__Group__1
+            {
+            pushFollow(FOLLOW_52);
+            rule__JvmWildcardTypeReference__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group__0"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group__0__Impl"
+    // InternalOXtype.g:15627:1: rule__JvmWildcardTypeReference__Group__0__Impl : ( () ) ;
+    public final void rule__JvmWildcardTypeReference__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15631:1: ( ( () ) )
+            // InternalOXtype.g:15632:1: ( () )
+            {
+            // InternalOXtype.g:15632:1: ( () )
+            // InternalOXtype.g:15633:2: ()
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); 
+            }
+            // InternalOXtype.g:15634:2: ()
+            // InternalOXtype.g:15634:3: 
+            {
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group__1"
+    // InternalOXtype.g:15642:1: rule__JvmWildcardTypeReference__Group__1 : rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 ;
+    public final void rule__JvmWildcardTypeReference__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15646:1: ( rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2 )
+            // InternalOXtype.g:15647:2: rule__JvmWildcardTypeReference__Group__1__Impl rule__JvmWildcardTypeReference__Group__2
+            {
+            pushFollow(FOLLOW_98);
+            rule__JvmWildcardTypeReference__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group__1"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group__1__Impl"
+    // InternalOXtype.g:15654:1: rule__JvmWildcardTypeReference__Group__1__Impl : ( '?' ) ;
+    public final void rule__JvmWildcardTypeReference__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15658:1: ( ( '?' ) )
+            // InternalOXtype.g:15659:1: ( '?' )
+            {
+            // InternalOXtype.g:15659:1: ( '?' )
+            // InternalOXtype.g:15660:2: '?'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); 
+            }
+            match(input,81,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group__1__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group__2"
+    // InternalOXtype.g:15669:1: rule__JvmWildcardTypeReference__Group__2 : rule__JvmWildcardTypeReference__Group__2__Impl ;
+    public final void rule__JvmWildcardTypeReference__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15673:1: ( rule__JvmWildcardTypeReference__Group__2__Impl )
+            // InternalOXtype.g:15674:2: rule__JvmWildcardTypeReference__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group__2"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group__2__Impl"
+    // InternalOXtype.g:15680:1: rule__JvmWildcardTypeReference__Group__2__Impl : ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) ;
+    public final void rule__JvmWildcardTypeReference__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15684:1: ( ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? ) )
+            // InternalOXtype.g:15685:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? )
+            {
+            // InternalOXtype.g:15685:1: ( ( rule__JvmWildcardTypeReference__Alternatives_2 )? )
+            // InternalOXtype.g:15686:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )?
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); 
+            }
+            // InternalOXtype.g:15687:2: ( rule__JvmWildcardTypeReference__Alternatives_2 )?
+            int alt127=2;
+            int LA127_0 = input.LA(1);
+
+            if ( (LA127_0==45||LA127_0==49) ) {
+                alt127=1;
+            }
+            switch (alt127) {
+                case 1 :
+                    // InternalOXtype.g:15687:3: rule__JvmWildcardTypeReference__Alternatives_2
+                    {
+                    pushFollow(FOLLOW_2);
+                    rule__JvmWildcardTypeReference__Alternatives_2();
+
+                    state._fsp--;
+                    if (state.failed) return ;
+
+                    }
+                    break;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getAlternatives_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group__2__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0"
+    // InternalOXtype.g:15696:1: rule__JvmWildcardTypeReference__Group_2_0__0 : rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 ;
+    public final void rule__JvmWildcardTypeReference__Group_2_0__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15700:1: ( rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1 )
+            // InternalOXtype.g:15701:2: rule__JvmWildcardTypeReference__Group_2_0__0__Impl rule__JvmWildcardTypeReference__Group_2_0__1
+            {
+            pushFollow(FOLLOW_99);
+            rule__JvmWildcardTypeReference__Group_2_0__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group_2_0__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__0__Impl"
+    // InternalOXtype.g:15708:1: rule__JvmWildcardTypeReference__Group_2_0__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) ;
+    public final void rule__JvmWildcardTypeReference__Group_2_0__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15712:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) ) )
+            // InternalOXtype.g:15713:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) )
+            {
+            // InternalOXtype.g:15713:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 ) )
+            // InternalOXtype.g:15714:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); 
+            }
+            // InternalOXtype.g:15715:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 )
+            // InternalOXtype.g:15715:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__0__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1"
+    // InternalOXtype.g:15723:1: rule__JvmWildcardTypeReference__Group_2_0__1 : rule__JvmWildcardTypeReference__Group_2_0__1__Impl ;
+    public final void rule__JvmWildcardTypeReference__Group_2_0__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15727:1: ( rule__JvmWildcardTypeReference__Group_2_0__1__Impl )
+            // InternalOXtype.g:15728:2: rule__JvmWildcardTypeReference__Group_2_0__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group_2_0__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_0__1__Impl"
+    // InternalOXtype.g:15734:1: rule__JvmWildcardTypeReference__Group_2_0__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) ;
+    public final void rule__JvmWildcardTypeReference__Group_2_0__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15738:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* ) )
+            // InternalOXtype.g:15739:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* )
+            {
+            // InternalOXtype.g:15739:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )* )
+            // InternalOXtype.g:15740:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); 
+            }
+            // InternalOXtype.g:15741:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 )*
+            loop128:
+            do {
+                int alt128=2;
+                int LA128_0 = input.LA(1);
+
+                if ( (LA128_0==82) ) {
+                    alt128=1;
+                }
+
+
+                switch (alt128) {
+            	case 1 :
+            	    // InternalOXtype.g:15741:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1
+            	    {
+            	    pushFollow(FOLLOW_100);
+            	    rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop128;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_0_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_0__1__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0"
+    // InternalOXtype.g:15750:1: rule__JvmWildcardTypeReference__Group_2_1__0 : rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 ;
+    public final void rule__JvmWildcardTypeReference__Group_2_1__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15754:1: ( rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1 )
+            // InternalOXtype.g:15755:2: rule__JvmWildcardTypeReference__Group_2_1__0__Impl rule__JvmWildcardTypeReference__Group_2_1__1
+            {
+            pushFollow(FOLLOW_99);
+            rule__JvmWildcardTypeReference__Group_2_1__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group_2_1__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__0__Impl"
+    // InternalOXtype.g:15762:1: rule__JvmWildcardTypeReference__Group_2_1__0__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) ;
+    public final void rule__JvmWildcardTypeReference__Group_2_1__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15766:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) ) )
+            // InternalOXtype.g:15767:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) )
+            {
+            // InternalOXtype.g:15767:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 ) )
+            // InternalOXtype.g:15768:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); 
+            }
+            // InternalOXtype.g:15769:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 )
+            // InternalOXtype.g:15769:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__0__Impl"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1"
+    // InternalOXtype.g:15777:1: rule__JvmWildcardTypeReference__Group_2_1__1 : rule__JvmWildcardTypeReference__Group_2_1__1__Impl ;
+    public final void rule__JvmWildcardTypeReference__Group_2_1__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15781:1: ( rule__JvmWildcardTypeReference__Group_2_1__1__Impl )
+            // InternalOXtype.g:15782:2: rule__JvmWildcardTypeReference__Group_2_1__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmWildcardTypeReference__Group_2_1__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__Group_2_1__1__Impl"
+    // InternalOXtype.g:15788:1: rule__JvmWildcardTypeReference__Group_2_1__1__Impl : ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) ;
+    public final void rule__JvmWildcardTypeReference__Group_2_1__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15792:1: ( ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* ) )
+            // InternalOXtype.g:15793:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* )
+            {
+            // InternalOXtype.g:15793:1: ( ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )* )
+            // InternalOXtype.g:15794:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )*
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); 
+            }
+            // InternalOXtype.g:15795:2: ( rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 )*
+            loop129:
+            do {
+                int alt129=2;
+                int LA129_0 = input.LA(1);
+
+                if ( (LA129_0==82) ) {
+                    alt129=1;
+                }
+
+
+                switch (alt129) {
+            	case 1 :
+            	    // InternalOXtype.g:15795:3: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1
+            	    {
+            	    pushFollow(FOLLOW_100);
+            	    rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1();
+
+            	    state._fsp--;
+            	    if (state.failed) return ;
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop129;
+                }
+            } while (true);
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsAssignment_2_1_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__Group_2_1__1__Impl"
+
+
+    // $ANTLR start "rule__JvmUpperBound__Group__0"
+    // InternalOXtype.g:15804:1: rule__JvmUpperBound__Group__0 : rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 ;
+    public final void rule__JvmUpperBound__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15808:1: ( rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1 )
+            // InternalOXtype.g:15809:2: rule__JvmUpperBound__Group__0__Impl rule__JvmUpperBound__Group__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__JvmUpperBound__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBound__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBound__Group__0"
+
+
+    // $ANTLR start "rule__JvmUpperBound__Group__0__Impl"
+    // InternalOXtype.g:15816:1: rule__JvmUpperBound__Group__0__Impl : ( 'extends' ) ;
+    public final void rule__JvmUpperBound__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15820:1: ( ( 'extends' ) )
+            // InternalOXtype.g:15821:1: ( 'extends' )
+            {
+            // InternalOXtype.g:15821:1: ( 'extends' )
+            // InternalOXtype.g:15822:2: 'extends'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); 
+            }
+            match(input,45,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBound__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmUpperBound__Group__1"
+    // InternalOXtype.g:15831:1: rule__JvmUpperBound__Group__1 : rule__JvmUpperBound__Group__1__Impl ;
+    public final void rule__JvmUpperBound__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15835:1: ( rule__JvmUpperBound__Group__1__Impl )
+            // InternalOXtype.g:15836:2: rule__JvmUpperBound__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBound__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBound__Group__1"
+
+
+    // $ANTLR start "rule__JvmUpperBound__Group__1__Impl"
+    // InternalOXtype.g:15842:1: rule__JvmUpperBound__Group__1__Impl : ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) ;
+    public final void rule__JvmUpperBound__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15846:1: ( ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) ) )
+            // InternalOXtype.g:15847:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) )
+            {
+            // InternalOXtype.g:15847:1: ( ( rule__JvmUpperBound__TypeReferenceAssignment_1 ) )
+            // InternalOXtype.g:15848:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); 
+            }
+            // InternalOXtype.g:15849:2: ( rule__JvmUpperBound__TypeReferenceAssignment_1 )
+            // InternalOXtype.g:15849:3: rule__JvmUpperBound__TypeReferenceAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBound__TypeReferenceAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBound__Group__1__Impl"
+
+
+    // $ANTLR start "rule__JvmUpperBoundAnded__Group__0"
+    // InternalOXtype.g:15858:1: rule__JvmUpperBoundAnded__Group__0 : rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 ;
+    public final void rule__JvmUpperBoundAnded__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15862:1: ( rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1 )
+            // InternalOXtype.g:15863:2: rule__JvmUpperBoundAnded__Group__0__Impl rule__JvmUpperBoundAnded__Group__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__JvmUpperBoundAnded__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBoundAnded__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBoundAnded__Group__0"
+
+
+    // $ANTLR start "rule__JvmUpperBoundAnded__Group__0__Impl"
+    // InternalOXtype.g:15870:1: rule__JvmUpperBoundAnded__Group__0__Impl : ( '&' ) ;
+    public final void rule__JvmUpperBoundAnded__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15874:1: ( ( '&' ) )
+            // InternalOXtype.g:15875:1: ( '&' )
+            {
+            // InternalOXtype.g:15875:1: ( '&' )
+            // InternalOXtype.g:15876:2: '&'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); 
+            }
+            match(input,82,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBoundAnded__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmUpperBoundAnded__Group__1"
+    // InternalOXtype.g:15885:1: rule__JvmUpperBoundAnded__Group__1 : rule__JvmUpperBoundAnded__Group__1__Impl ;
+    public final void rule__JvmUpperBoundAnded__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15889:1: ( rule__JvmUpperBoundAnded__Group__1__Impl )
+            // InternalOXtype.g:15890:2: rule__JvmUpperBoundAnded__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBoundAnded__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBoundAnded__Group__1"
+
+
+    // $ANTLR start "rule__JvmUpperBoundAnded__Group__1__Impl"
+    // InternalOXtype.g:15896:1: rule__JvmUpperBoundAnded__Group__1__Impl : ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) ;
+    public final void rule__JvmUpperBoundAnded__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15900:1: ( ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) ) )
+            // InternalOXtype.g:15901:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) )
+            {
+            // InternalOXtype.g:15901:1: ( ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 ) )
+            // InternalOXtype.g:15902:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); 
+            }
+            // InternalOXtype.g:15903:2: ( rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 )
+            // InternalOXtype.g:15903:3: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmUpperBoundAnded__TypeReferenceAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBoundAnded__Group__1__Impl"
+
+
+    // $ANTLR start "rule__JvmLowerBound__Group__0"
+    // InternalOXtype.g:15912:1: rule__JvmLowerBound__Group__0 : rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 ;
+    public final void rule__JvmLowerBound__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15916:1: ( rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1 )
+            // InternalOXtype.g:15917:2: rule__JvmLowerBound__Group__0__Impl rule__JvmLowerBound__Group__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__JvmLowerBound__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBound__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBound__Group__0"
+
+
+    // $ANTLR start "rule__JvmLowerBound__Group__0__Impl"
+    // InternalOXtype.g:15924:1: rule__JvmLowerBound__Group__0__Impl : ( 'super' ) ;
+    public final void rule__JvmLowerBound__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15928:1: ( ( 'super' ) )
+            // InternalOXtype.g:15929:1: ( 'super' )
+            {
+            // InternalOXtype.g:15929:1: ( 'super' )
+            // InternalOXtype.g:15930:2: 'super'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); 
+            }
+            match(input,49,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBound__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmLowerBound__Group__1"
+    // InternalOXtype.g:15939:1: rule__JvmLowerBound__Group__1 : rule__JvmLowerBound__Group__1__Impl ;
+    public final void rule__JvmLowerBound__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15943:1: ( rule__JvmLowerBound__Group__1__Impl )
+            // InternalOXtype.g:15944:2: rule__JvmLowerBound__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBound__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBound__Group__1"
+
+
+    // $ANTLR start "rule__JvmLowerBound__Group__1__Impl"
+    // InternalOXtype.g:15950:1: rule__JvmLowerBound__Group__1__Impl : ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) ;
+    public final void rule__JvmLowerBound__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15954:1: ( ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) ) )
+            // InternalOXtype.g:15955:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) )
+            {
+            // InternalOXtype.g:15955:1: ( ( rule__JvmLowerBound__TypeReferenceAssignment_1 ) )
+            // InternalOXtype.g:15956:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); 
+            }
+            // InternalOXtype.g:15957:2: ( rule__JvmLowerBound__TypeReferenceAssignment_1 )
+            // InternalOXtype.g:15957:3: rule__JvmLowerBound__TypeReferenceAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBound__TypeReferenceAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBound__Group__1__Impl"
+
+
+    // $ANTLR start "rule__JvmLowerBoundAnded__Group__0"
+    // InternalOXtype.g:15966:1: rule__JvmLowerBoundAnded__Group__0 : rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 ;
+    public final void rule__JvmLowerBoundAnded__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15970:1: ( rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1 )
+            // InternalOXtype.g:15971:2: rule__JvmLowerBoundAnded__Group__0__Impl rule__JvmLowerBoundAnded__Group__1
+            {
+            pushFollow(FOLLOW_32);
+            rule__JvmLowerBoundAnded__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBoundAnded__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBoundAnded__Group__0"
+
+
+    // $ANTLR start "rule__JvmLowerBoundAnded__Group__0__Impl"
+    // InternalOXtype.g:15978:1: rule__JvmLowerBoundAnded__Group__0__Impl : ( '&' ) ;
+    public final void rule__JvmLowerBoundAnded__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15982:1: ( ( '&' ) )
+            // InternalOXtype.g:15983:1: ( '&' )
+            {
+            // InternalOXtype.g:15983:1: ( '&' )
+            // InternalOXtype.g:15984:2: '&'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); 
+            }
+            match(input,82,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBoundAnded__Group__0__Impl"
+
+
+    // $ANTLR start "rule__JvmLowerBoundAnded__Group__1"
+    // InternalOXtype.g:15993:1: rule__JvmLowerBoundAnded__Group__1 : rule__JvmLowerBoundAnded__Group__1__Impl ;
+    public final void rule__JvmLowerBoundAnded__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:15997:1: ( rule__JvmLowerBoundAnded__Group__1__Impl )
+            // InternalOXtype.g:15998:2: rule__JvmLowerBoundAnded__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBoundAnded__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBoundAnded__Group__1"
+
+
+    // $ANTLR start "rule__JvmLowerBoundAnded__Group__1__Impl"
+    // InternalOXtype.g:16004:1: rule__JvmLowerBoundAnded__Group__1__Impl : ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) ;
+    public final void rule__JvmLowerBoundAnded__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16008:1: ( ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) ) )
+            // InternalOXtype.g:16009:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) )
+            {
+            // InternalOXtype.g:16009:1: ( ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 ) )
+            // InternalOXtype.g:16010:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); 
+            }
+            // InternalOXtype.g:16011:2: ( rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 )
+            // InternalOXtype.g:16011:3: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1
+            {
+            pushFollow(FOLLOW_2);
+            rule__JvmLowerBoundAnded__TypeReferenceAssignment_1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceAssignment_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBoundAnded__Group__1__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0"
+    // InternalOXtype.g:16020:1: rule__QualifiedNameWithWildcard__Group__0 : rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 ;
+    public final void rule__QualifiedNameWithWildcard__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16024:1: ( rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1 )
+            // InternalOXtype.g:16025:2: rule__QualifiedNameWithWildcard__Group__0__Impl rule__QualifiedNameWithWildcard__Group__1
+            {
+            pushFollow(FOLLOW_94);
+            rule__QualifiedNameWithWildcard__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__0__Impl"
+    // InternalOXtype.g:16032:1: rule__QualifiedNameWithWildcard__Group__0__Impl : ( ruleQualifiedName ) ;
+    public final void rule__QualifiedNameWithWildcard__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16036:1: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:16037:1: ( ruleQualifiedName )
+            {
+            // InternalOXtype.g:16037:1: ( ruleQualifiedName )
+            // InternalOXtype.g:16038:2: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1"
+    // InternalOXtype.g:16047:1: rule__QualifiedNameWithWildcard__Group__1 : rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 ;
+    public final void rule__QualifiedNameWithWildcard__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16051:1: ( rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2 )
+            // InternalOXtype.g:16052:2: rule__QualifiedNameWithWildcard__Group__1__Impl rule__QualifiedNameWithWildcard__Group__2
+            {
+            pushFollow(FOLLOW_101);
+            rule__QualifiedNameWithWildcard__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__2();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__1__Impl"
+    // InternalOXtype.g:16059:1: rule__QualifiedNameWithWildcard__Group__1__Impl : ( '.' ) ;
+    public final void rule__QualifiedNameWithWildcard__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16063:1: ( ( '.' ) )
+            // InternalOXtype.g:16064:1: ( '.' )
+            {
+            // InternalOXtype.g:16064:1: ( '.' )
+            // InternalOXtype.g:16065:2: '.'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); 
+            }
+            match(input,43,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__1__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2"
+    // InternalOXtype.g:16074:1: rule__QualifiedNameWithWildcard__Group__2 : rule__QualifiedNameWithWildcard__Group__2__Impl ;
+    public final void rule__QualifiedNameWithWildcard__Group__2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16078:1: ( rule__QualifiedNameWithWildcard__Group__2__Impl )
+            // InternalOXtype.g:16079:2: rule__QualifiedNameWithWildcard__Group__2__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameWithWildcard__Group__2__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2"
+
+
+    // $ANTLR start "rule__QualifiedNameWithWildcard__Group__2__Impl"
+    // InternalOXtype.g:16085:1: rule__QualifiedNameWithWildcard__Group__2__Impl : ( '*' ) ;
+    public final void rule__QualifiedNameWithWildcard__Group__2__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16089:1: ( ( '*' ) )
+            // InternalOXtype.g:16090:1: ( '*' )
+            {
+            // InternalOXtype.g:16090:1: ( '*' )
+            // InternalOXtype.g:16091:2: '*'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); 
+            }
+            match(input,36,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameWithWildcard__Group__2__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0"
+    // InternalOXtype.g:16101:1: rule__QualifiedNameInStaticImport__Group__0 : rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 ;
+    public final void rule__QualifiedNameInStaticImport__Group__0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16105:1: ( rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1 )
+            // InternalOXtype.g:16106:2: rule__QualifiedNameInStaticImport__Group__0__Impl rule__QualifiedNameInStaticImport__Group__1
+            {
+            pushFollow(FOLLOW_94);
+            rule__QualifiedNameInStaticImport__Group__0__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameInStaticImport__Group__1();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0"
+
+
+    // $ANTLR start "rule__QualifiedNameInStaticImport__Group__0__Impl"
+    // InternalOXtype.g:16113:1: rule__QualifiedNameInStaticImport__Group__0__Impl : ( ruleValidID ) ;
+    public final void rule__QualifiedNameInStaticImport__Group__0__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16117:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:16118:1: ( ruleValidID )
+            {
+            // InternalOXtype.g:16118:1: ( ruleValidID )
+            // InternalOXtype.g:16119:2: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameInStaticImport__Group__0__Impl"
+
+
+    // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1"
+    // InternalOXtype.g:16128:1: rule__QualifiedNameInStaticImport__Group__1 : rule__QualifiedNameInStaticImport__Group__1__Impl ;
+    public final void rule__QualifiedNameInStaticImport__Group__1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16132:1: ( rule__QualifiedNameInStaticImport__Group__1__Impl )
+            // InternalOXtype.g:16133:2: rule__QualifiedNameInStaticImport__Group__1__Impl
+            {
+            pushFollow(FOLLOW_2);
+            rule__QualifiedNameInStaticImport__Group__1__Impl();
+
+            state._fsp--;
+            if (state.failed) return ;
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1"
+
+
+    // $ANTLR start "rule__QualifiedNameInStaticImport__Group__1__Impl"
+    // InternalOXtype.g:16139:1: rule__QualifiedNameInStaticImport__Group__1__Impl : ( '.' ) ;
+    public final void rule__QualifiedNameInStaticImport__Group__1__Impl() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16143:1: ( ( '.' ) )
+            // InternalOXtype.g:16144:1: ( '.' )
+            {
+            // InternalOXtype.g:16144:1: ( '.' )
+            // InternalOXtype.g:16145:2: '.'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); 
+            }
+            match(input,43,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__QualifiedNameInStaticImport__Group__1__Impl"
+
+
+    // $ANTLR start "rule__XImportDeclaration__StaticAssignment_2_0_0"
+    // InternalOXtype.g:16155:1: rule__XImportDeclaration__StaticAssignment_2_0_0 : ( ( 'static' ) ) ;
+    public final void rule__XImportDeclaration__StaticAssignment_2_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16159:1: ( ( ( 'static' ) ) )
+            // InternalOXtype.g:16160:2: ( ( 'static' ) )
+            {
+            // InternalOXtype.g:16160:2: ( ( 'static' ) )
+            // InternalOXtype.g:16161:3: ( 'static' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); 
+            }
+            // InternalOXtype.g:16162:3: ( 'static' )
+            // InternalOXtype.g:16163:4: 'static'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); 
+            }
+            match(input,46,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__StaticAssignment_2_0_0"
+
+
+    // $ANTLR start "rule__XImportDeclaration__ExtensionAssignment_2_0_1"
+    // InternalOXtype.g:16174:1: rule__XImportDeclaration__ExtensionAssignment_2_0_1 : ( ( 'extension' ) ) ;
+    public final void rule__XImportDeclaration__ExtensionAssignment_2_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16178:1: ( ( ( 'extension' ) ) )
+            // InternalOXtype.g:16179:2: ( ( 'extension' ) )
+            {
+            // InternalOXtype.g:16179:2: ( ( 'extension' ) )
+            // InternalOXtype.g:16180:3: ( 'extension' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); 
+            }
+            // InternalOXtype.g:16181:3: ( 'extension' )
+            // InternalOXtype.g:16182:4: 'extension'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); 
+            }
+            match(input,48,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__ExtensionAssignment_2_0_1"
+
+
+    // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_2_0_2"
+    // InternalOXtype.g:16193:1: rule__XImportDeclaration__ImportedTypeAssignment_2_0_2 : ( ( ruleQualifiedNameInStaticImport ) ) ;
+    public final void rule__XImportDeclaration__ImportedTypeAssignment_2_0_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16197:1: ( ( ( ruleQualifiedNameInStaticImport ) ) )
+            // InternalOXtype.g:16198:2: ( ( ruleQualifiedNameInStaticImport ) )
+            {
+            // InternalOXtype.g:16198:2: ( ( ruleQualifiedNameInStaticImport ) )
+            // InternalOXtype.g:16199:3: ( ruleQualifiedNameInStaticImport )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0()); 
+            }
+            // InternalOXtype.g:16200:3: ( ruleQualifiedNameInStaticImport )
+            // InternalOXtype.g:16201:4: ruleQualifiedNameInStaticImport
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedNameInStaticImport();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_2_0_2"
+
+
+    // $ANTLR start "rule__XImportDeclaration__WildcardAssignment_2_0_3_0"
+    // InternalOXtype.g:16212:1: rule__XImportDeclaration__WildcardAssignment_2_0_3_0 : ( ( '*' ) ) ;
+    public final void rule__XImportDeclaration__WildcardAssignment_2_0_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16216:1: ( ( ( '*' ) ) )
+            // InternalOXtype.g:16217:2: ( ( '*' ) )
+            {
+            // InternalOXtype.g:16217:2: ( ( '*' ) )
+            // InternalOXtype.g:16218:3: ( '*' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); 
+            }
+            // InternalOXtype.g:16219:3: ( '*' )
+            // InternalOXtype.g:16220:4: '*'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); 
+            }
+            match(input,36,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__WildcardAssignment_2_0_3_0"
+
+
+    // $ANTLR start "rule__XImportDeclaration__MemberNameAssignment_2_0_3_1"
+    // InternalOXtype.g:16231:1: rule__XImportDeclaration__MemberNameAssignment_2_0_3_1 : ( ruleValidID ) ;
+    public final void rule__XImportDeclaration__MemberNameAssignment_2_0_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16235:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:16236:2: ( ruleValidID )
+            {
+            // InternalOXtype.g:16236:2: ( ruleValidID )
+            // InternalOXtype.g:16237:3: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__MemberNameAssignment_2_0_3_1"
+
+
+    // $ANTLR start "rule__XImportDeclaration__ImportedTypeAssignment_2_1"
+    // InternalOXtype.g:16246:1: rule__XImportDeclaration__ImportedTypeAssignment_2_1 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__XImportDeclaration__ImportedTypeAssignment_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16250:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalOXtype.g:16251:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalOXtype.g:16251:2: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:16252:3: ( ruleQualifiedName )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0()); 
+            }
+            // InternalOXtype.g:16253:3: ( ruleQualifiedName )
+            // InternalOXtype.g:16254:4: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__ImportedTypeAssignment_2_1"
+
+
+    // $ANTLR start "rule__XImportDeclaration__ImportedNamespaceAssignment_2_2"
+    // InternalOXtype.g:16265:1: rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 : ( ruleQualifiedNameWithWildcard ) ;
+    public final void rule__XImportDeclaration__ImportedNamespaceAssignment_2_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16269:1: ( ( ruleQualifiedNameWithWildcard ) )
+            // InternalOXtype.g:16270:2: ( ruleQualifiedNameWithWildcard )
+            {
+            // InternalOXtype.g:16270:2: ( ruleQualifiedNameWithWildcard )
+            // InternalOXtype.g:16271:3: ruleQualifiedNameWithWildcard
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedNameWithWildcard();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__ImportedNamespaceAssignment_2_2"
+
+
+    // $ANTLR start "rule__XImportDeclaration__FqnImportAssignment_2_3_0"
+    // InternalOXtype.g:16280:1: rule__XImportDeclaration__FqnImportAssignment_2_3_0 : ( ( 'ns' ) ) ;
+    public final void rule__XImportDeclaration__FqnImportAssignment_2_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16284:1: ( ( ( 'ns' ) ) )
+            // InternalOXtype.g:16285:2: ( ( 'ns' ) )
+            {
+            // InternalOXtype.g:16285:2: ( ( 'ns' ) )
+            // InternalOXtype.g:16286:3: ( 'ns' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); 
+            }
+            // InternalOXtype.g:16287:3: ( 'ns' )
+            // InternalOXtype.g:16288:4: 'ns'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); 
+            }
+            match(input,83,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__FqnImportAssignment_2_3_0"
+
+
+    // $ANTLR start "rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1"
+    // InternalOXtype.g:16299:1: rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1 : ( ruleQualifiedName ) ;
+    public final void rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16303:1: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:16304:2: ( ruleQualifiedName )
+            {
+            // InternalOXtype.g:16304:2: ( ruleQualifiedName )
+            // InternalOXtype.g:16305:3: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XImportDeclaration__ImportedFullyQualifiedNameAssignment_2_3_1"
+
+
+    // $ANTLR start "rule__XAnnotation__AnnotationTypeAssignment_2"
+    // InternalOXtype.g:16314:1: rule__XAnnotation__AnnotationTypeAssignment_2 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__XAnnotation__AnnotationTypeAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16318:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalOXtype.g:16319:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalOXtype.g:16319:2: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:16320:3: ( ruleQualifiedName )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0()); 
+            }
+            // InternalOXtype.g:16321:3: ( ruleQualifiedName )
+            // InternalOXtype.g:16322:4: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeQualifiedNameParserRuleCall_2_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__AnnotationTypeAssignment_2"
+
+
+    // $ANTLR start "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0"
+    // InternalOXtype.g:16333:1: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0 : ( ruleXAnnotationElementValuePair ) ;
+    public final void rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16337:1: ( ( ruleXAnnotationElementValuePair ) )
+            // InternalOXtype.g:16338:2: ( ruleXAnnotationElementValuePair )
+            {
+            // InternalOXtype.g:16338:2: ( ruleXAnnotationElementValuePair )
+            // InternalOXtype.g:16339:3: ruleXAnnotationElementValuePair
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationElementValuePair();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_0"
+
+
+    // $ANTLR start "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1"
+    // InternalOXtype.g:16348:1: rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1 : ( ruleXAnnotationElementValuePair ) ;
+    public final void rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16352:1: ( ( ruleXAnnotationElementValuePair ) )
+            // InternalOXtype.g:16353:2: ( ruleXAnnotationElementValuePair )
+            {
+            // InternalOXtype.g:16353:2: ( ruleXAnnotationElementValuePair )
+            // InternalOXtype.g:16354:3: ruleXAnnotationElementValuePair
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationElementValuePair();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__ElementValuePairsAssignment_3_1_0_1_1"
+
+
+    // $ANTLR start "rule__XAnnotation__ValueAssignment_3_1_1"
+    // InternalOXtype.g:16363:1: rule__XAnnotation__ValueAssignment_3_1_1 : ( ruleXAnnotationElementValueOrCommaList ) ;
+    public final void rule__XAnnotation__ValueAssignment_3_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16367:1: ( ( ruleXAnnotationElementValueOrCommaList ) )
+            // InternalOXtype.g:16368:2: ( ruleXAnnotationElementValueOrCommaList )
+            {
+            // InternalOXtype.g:16368:2: ( ruleXAnnotationElementValueOrCommaList )
+            // InternalOXtype.g:16369:3: ruleXAnnotationElementValueOrCommaList
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationElementValueOrCommaList();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotation__ValueAssignment_3_1_1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__ElementAssignment_0_0_0"
+    // InternalOXtype.g:16378:1: rule__XAnnotationElementValuePair__ElementAssignment_0_0_0 : ( ( ruleValidID ) ) ;
+    public final void rule__XAnnotationElementValuePair__ElementAssignment_0_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16382:1: ( ( ( ruleValidID ) ) )
+            // InternalOXtype.g:16383:2: ( ( ruleValidID ) )
+            {
+            // InternalOXtype.g:16383:2: ( ( ruleValidID ) )
+            // InternalOXtype.g:16384:3: ( ruleValidID )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0()); 
+            }
+            // InternalOXtype.g:16385:3: ( ruleValidID )
+            // InternalOXtype.g:16386:4: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationValidIDParserRuleCall_0_0_0_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__ElementAssignment_0_0_0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValuePair__ValueAssignment_1"
+    // InternalOXtype.g:16397:1: rule__XAnnotationElementValuePair__ValueAssignment_1 : ( ruleXAnnotationElementValue ) ;
+    public final void rule__XAnnotationElementValuePair__ValueAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16401:1: ( ( ruleXAnnotationElementValue ) )
+            // InternalOXtype.g:16402:2: ( ruleXAnnotationElementValue )
+            {
+            // InternalOXtype.g:16402:2: ( ruleXAnnotationElementValue )
+            // InternalOXtype.g:16403:3: ruleXAnnotationElementValue
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationElementValue();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValuePair__ValueAssignment_1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0"
+    // InternalOXtype.g:16412:1: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0 : ( ruleXAnnotationOrExpression ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16416:1: ( ( ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:16417:2: ( ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:16417:2: ( ruleXAnnotationOrExpression )
+            // InternalOXtype.g:16418:3: ruleXAnnotationOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1"
+    // InternalOXtype.g:16427:1: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1 : ( ruleXAnnotationOrExpression ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16431:1: ( ( ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:16432:2: ( ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:16432:2: ( ruleXAnnotationOrExpression )
+            // InternalOXtype.g:16433:3: ruleXAnnotationOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_0_1_1_1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1"
+    // InternalOXtype.g:16442:1: rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1 : ( ruleXAnnotationOrExpression ) ;
+    public final void rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16446:1: ( ( ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:16447:2: ( ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:16447:2: ( ruleXAnnotationOrExpression )
+            // InternalOXtype.g:16448:3: ruleXAnnotationOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValueOrCommaList__ElementsAssignment_1_1_1_1"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__ElementsAssignment_0_1_0"
+    // InternalOXtype.g:16457:1: rule__XAnnotationElementValue__ElementsAssignment_0_1_0 : ( ruleXAnnotationOrExpression ) ;
+    public final void rule__XAnnotationElementValue__ElementsAssignment_0_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16461:1: ( ( ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:16462:2: ( ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:16462:2: ( ruleXAnnotationOrExpression )
+            // InternalOXtype.g:16463:3: ruleXAnnotationOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__ElementsAssignment_0_1_0"
+
+
+    // $ANTLR start "rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1"
+    // InternalOXtype.g:16472:1: rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1 : ( ruleXAnnotationOrExpression ) ;
+    public final void rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16476:1: ( ( ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:16477:2: ( ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:16477:2: ( ruleXAnnotationOrExpression )
+            // InternalOXtype.g:16478:3: ruleXAnnotationOrExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAnnotationElementValue__ElementsAssignment_0_1_1_1"
+
+
+    // $ANTLR start "rule__XAssignment__FeatureAssignment_0_1"
+    // InternalOXtype.g:16487:1: rule__XAssignment__FeatureAssignment_0_1 : ( ( ruleFeatureCallID ) ) ;
+    public final void rule__XAssignment__FeatureAssignment_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16491:1: ( ( ( ruleFeatureCallID ) ) )
+            // InternalOXtype.g:16492:2: ( ( ruleFeatureCallID ) )
+            {
+            // InternalOXtype.g:16492:2: ( ( ruleFeatureCallID ) )
+            // InternalOXtype.g:16493:3: ( ruleFeatureCallID )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); 
+            }
+            // InternalOXtype.g:16494:3: ( ruleFeatureCallID )
+            // InternalOXtype.g:16495:4: ruleFeatureCallID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleFeatureCallID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__FeatureAssignment_0_1"
+
+
+    // $ANTLR start "rule__XAssignment__ValueAssignment_0_3"
+    // InternalOXtype.g:16506:1: rule__XAssignment__ValueAssignment_0_3 : ( ruleXAssignment ) ;
+    public final void rule__XAssignment__ValueAssignment_0_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16510:1: ( ( ruleXAssignment ) )
+            // InternalOXtype.g:16511:2: ( ruleXAssignment )
+            {
+            // InternalOXtype.g:16511:2: ( ruleXAssignment )
+            // InternalOXtype.g:16512:3: ruleXAssignment
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__ValueAssignment_0_3"
+
+
+    // $ANTLR start "rule__XAssignment__FeatureAssignment_1_1_0_0_1"
+    // InternalOXtype.g:16521:1: rule__XAssignment__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpMultiAssign ) ) ;
+    public final void rule__XAssignment__FeatureAssignment_1_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16525:1: ( ( ( ruleOpMultiAssign ) ) )
+            // InternalOXtype.g:16526:2: ( ( ruleOpMultiAssign ) )
+            {
+            // InternalOXtype.g:16526:2: ( ( ruleOpMultiAssign ) )
+            // InternalOXtype.g:16527:3: ( ruleOpMultiAssign )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16528:3: ( ruleOpMultiAssign )
+            // InternalOXtype.g:16529:4: ruleOpMultiAssign
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpMultiAssign();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementOpMultiAssignParserRuleCall_1_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__FeatureAssignment_1_1_0_0_1"
+
+
+    // $ANTLR start "rule__XAssignment__RightOperandAssignment_1_1_1"
+    // InternalOXtype.g:16540:1: rule__XAssignment__RightOperandAssignment_1_1_1 : ( ruleXAssignment ) ;
+    public final void rule__XAssignment__RightOperandAssignment_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16544:1: ( ( ruleXAssignment ) )
+            // InternalOXtype.g:16545:2: ( ruleXAssignment )
+            {
+            // InternalOXtype.g:16545:2: ( ruleXAssignment )
+            // InternalOXtype.g:16546:3: ruleXAssignment
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAssignment__RightOperandAssignment_1_1_1"
+
+
+    // $ANTLR start "rule__XOrExpression__FeatureAssignment_1_0_0_1"
+    // InternalOXtype.g:16555:1: rule__XOrExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOr ) ) ;
+    public final void rule__XOrExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16559:1: ( ( ( ruleOpOr ) ) )
+            // InternalOXtype.g:16560:2: ( ( ruleOpOr ) )
+            {
+            // InternalOXtype.g:16560:2: ( ( ruleOpOr ) )
+            // InternalOXtype.g:16561:3: ( ruleOpOr )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16562:3: ( ruleOpOr )
+            // InternalOXtype.g:16563:4: ruleOpOr
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpOr();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementOpOrParserRuleCall_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__FeatureAssignment_1_0_0_1"
+
+
+    // $ANTLR start "rule__XOrExpression__RightOperandAssignment_1_1"
+    // InternalOXtype.g:16574:1: rule__XOrExpression__RightOperandAssignment_1_1 : ( ruleXAndExpression ) ;
+    public final void rule__XOrExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16578:1: ( ( ruleXAndExpression ) )
+            // InternalOXtype.g:16579:2: ( ruleXAndExpression )
+            {
+            // InternalOXtype.g:16579:2: ( ruleXAndExpression )
+            // InternalOXtype.g:16580:3: ruleXAndExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAndExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOrExpression__RightOperandAssignment_1_1"
+
+
+    // $ANTLR start "rule__XAndExpression__FeatureAssignment_1_0_0_1"
+    // InternalOXtype.g:16589:1: rule__XAndExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAnd ) ) ;
+    public final void rule__XAndExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16593:1: ( ( ( ruleOpAnd ) ) )
+            // InternalOXtype.g:16594:2: ( ( ruleOpAnd ) )
+            {
+            // InternalOXtype.g:16594:2: ( ( ruleOpAnd ) )
+            // InternalOXtype.g:16595:3: ( ruleOpAnd )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16596:3: ( ruleOpAnd )
+            // InternalOXtype.g:16597:4: ruleOpAnd
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpAnd();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementOpAndParserRuleCall_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__FeatureAssignment_1_0_0_1"
+
+
+    // $ANTLR start "rule__XAndExpression__RightOperandAssignment_1_1"
+    // InternalOXtype.g:16608:1: rule__XAndExpression__RightOperandAssignment_1_1 : ( ruleXEqualityExpression ) ;
+    public final void rule__XAndExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16612:1: ( ( ruleXEqualityExpression ) )
+            // InternalOXtype.g:16613:2: ( ruleXEqualityExpression )
+            {
+            // InternalOXtype.g:16613:2: ( ruleXEqualityExpression )
+            // InternalOXtype.g:16614:3: ruleXEqualityExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXEqualityExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAndExpression__RightOperandAssignment_1_1"
+
+
+    // $ANTLR start "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"
+    // InternalOXtype.g:16623:1: rule__XEqualityExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpEquality ) ) ;
+    public final void rule__XEqualityExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16627:1: ( ( ( ruleOpEquality ) ) )
+            // InternalOXtype.g:16628:2: ( ( ruleOpEquality ) )
+            {
+            // InternalOXtype.g:16628:2: ( ( ruleOpEquality ) )
+            // InternalOXtype.g:16629:3: ( ruleOpEquality )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16630:3: ( ruleOpEquality )
+            // InternalOXtype.g:16631:4: ruleOpEquality
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpEquality();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementOpEqualityParserRuleCall_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__FeatureAssignment_1_0_0_1"
+
+
+    // $ANTLR start "rule__XEqualityExpression__RightOperandAssignment_1_1"
+    // InternalOXtype.g:16642:1: rule__XEqualityExpression__RightOperandAssignment_1_1 : ( ruleXRelationalExpression ) ;
+    public final void rule__XEqualityExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16646:1: ( ( ruleXRelationalExpression ) )
+            // InternalOXtype.g:16647:2: ( ruleXRelationalExpression )
+            {
+            // InternalOXtype.g:16647:2: ( ruleXRelationalExpression )
+            // InternalOXtype.g:16648:3: ruleXRelationalExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXRelationalExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XEqualityExpression__RightOperandAssignment_1_1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__TypeAssignment_1_0_1"
+    // InternalOXtype.g:16657:1: rule__XRelationalExpression__TypeAssignment_1_0_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__XRelationalExpression__TypeAssignment_1_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16661:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:16662:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:16662:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:16663:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__TypeAssignment_1_0_1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"
+    // InternalOXtype.g:16672:1: rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1 : ( ( ruleOpCompare ) ) ;
+    public final void rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16676:1: ( ( ( ruleOpCompare ) ) )
+            // InternalOXtype.g:16677:2: ( ( ruleOpCompare ) )
+            {
+            // InternalOXtype.g:16677:2: ( ( ruleOpCompare ) )
+            // InternalOXtype.g:16678:3: ( ruleOpCompare )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16679:3: ( ruleOpCompare )
+            // InternalOXtype.g:16680:4: ruleOpCompare
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpCompare();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementOpCompareParserRuleCall_1_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__FeatureAssignment_1_1_0_0_1"
+
+
+    // $ANTLR start "rule__XRelationalExpression__RightOperandAssignment_1_1_1"
+    // InternalOXtype.g:16691:1: rule__XRelationalExpression__RightOperandAssignment_1_1_1 : ( ruleXOtherOperatorExpression ) ;
+    public final void rule__XRelationalExpression__RightOperandAssignment_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16695:1: ( ( ruleXOtherOperatorExpression ) )
+            // InternalOXtype.g:16696:2: ( ruleXOtherOperatorExpression )
+            {
+            // InternalOXtype.g:16696:2: ( ruleXOtherOperatorExpression )
+            // InternalOXtype.g:16697:3: ruleXOtherOperatorExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXOtherOperatorExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XRelationalExpression__RightOperandAssignment_1_1_1"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"
+    // InternalOXtype.g:16706:1: rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpOther ) ) ;
+    public final void rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16710:1: ( ( ( ruleOpOther ) ) )
+            // InternalOXtype.g:16711:2: ( ( ruleOpOther ) )
+            {
+            // InternalOXtype.g:16711:2: ( ( ruleOpOther ) )
+            // InternalOXtype.g:16712:3: ( ruleOpOther )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16713:3: ( ruleOpOther )
+            // InternalOXtype.g:16714:4: ruleOpOther
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpOther();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementOpOtherParserRuleCall_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__FeatureAssignment_1_0_0_1"
+
+
+    // $ANTLR start "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"
+    // InternalOXtype.g:16725:1: rule__XOtherOperatorExpression__RightOperandAssignment_1_1 : ( ruleXAdditiveExpression ) ;
+    public final void rule__XOtherOperatorExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16729:1: ( ( ruleXAdditiveExpression ) )
+            // InternalOXtype.g:16730:2: ( ruleXAdditiveExpression )
+            {
+            // InternalOXtype.g:16730:2: ( ruleXAdditiveExpression )
+            // InternalOXtype.g:16731:3: ruleXAdditiveExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAdditiveExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XOtherOperatorExpression__RightOperandAssignment_1_1"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"
+    // InternalOXtype.g:16740:1: rule__XAdditiveExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpAdd ) ) ;
+    public final void rule__XAdditiveExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16744:1: ( ( ( ruleOpAdd ) ) )
+            // InternalOXtype.g:16745:2: ( ( ruleOpAdd ) )
+            {
+            // InternalOXtype.g:16745:2: ( ( ruleOpAdd ) )
+            // InternalOXtype.g:16746:3: ( ruleOpAdd )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16747:3: ( ruleOpAdd )
+            // InternalOXtype.g:16748:4: ruleOpAdd
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpAdd();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementOpAddParserRuleCall_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__FeatureAssignment_1_0_0_1"
+
+
+    // $ANTLR start "rule__XAdditiveExpression__RightOperandAssignment_1_1"
+    // InternalOXtype.g:16759:1: rule__XAdditiveExpression__RightOperandAssignment_1_1 : ( ruleXMultiplicativeExpression ) ;
+    public final void rule__XAdditiveExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16763:1: ( ( ruleXMultiplicativeExpression ) )
+            // InternalOXtype.g:16764:2: ( ruleXMultiplicativeExpression )
+            {
+            // InternalOXtype.g:16764:2: ( ruleXMultiplicativeExpression )
+            // InternalOXtype.g:16765:3: ruleXMultiplicativeExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXMultiplicativeExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XAdditiveExpression__RightOperandAssignment_1_1"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"
+    // InternalOXtype.g:16774:1: rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1 : ( ( ruleOpMulti ) ) ;
+    public final void rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16778:1: ( ( ( ruleOpMulti ) ) )
+            // InternalOXtype.g:16779:2: ( ( ruleOpMulti ) )
+            {
+            // InternalOXtype.g:16779:2: ( ( ruleOpMulti ) )
+            // InternalOXtype.g:16780:3: ( ruleOpMulti )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+            // InternalOXtype.g:16781:3: ( ruleOpMulti )
+            // InternalOXtype.g:16782:4: ruleOpMulti
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpMulti();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementOpMultiParserRuleCall_1_0_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__FeatureAssignment_1_0_0_1"
+
+
+    // $ANTLR start "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"
+    // InternalOXtype.g:16793:1: rule__XMultiplicativeExpression__RightOperandAssignment_1_1 : ( ruleXUnaryOperation ) ;
+    public final void rule__XMultiplicativeExpression__RightOperandAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16797:1: ( ( ruleXUnaryOperation ) )
+            // InternalOXtype.g:16798:2: ( ruleXUnaryOperation )
+            {
+            // InternalOXtype.g:16798:2: ( ruleXUnaryOperation )
+            // InternalOXtype.g:16799:3: ruleXUnaryOperation
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXUnaryOperation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMultiplicativeExpression__RightOperandAssignment_1_1"
+
+
+    // $ANTLR start "rule__XUnaryOperation__FeatureAssignment_0_1"
+    // InternalOXtype.g:16808:1: rule__XUnaryOperation__FeatureAssignment_0_1 : ( ( ruleOpUnary ) ) ;
+    public final void rule__XUnaryOperation__FeatureAssignment_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16812:1: ( ( ( ruleOpUnary ) ) )
+            // InternalOXtype.g:16813:2: ( ( ruleOpUnary ) )
+            {
+            // InternalOXtype.g:16813:2: ( ( ruleOpUnary ) )
+            // InternalOXtype.g:16814:3: ( ruleOpUnary )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); 
+            }
+            // InternalOXtype.g:16815:3: ( ruleOpUnary )
+            // InternalOXtype.g:16816:4: ruleOpUnary
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpUnary();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementOpUnaryParserRuleCall_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__FeatureAssignment_0_1"
+
+
+    // $ANTLR start "rule__XUnaryOperation__OperandAssignment_0_2"
+    // InternalOXtype.g:16827:1: rule__XUnaryOperation__OperandAssignment_0_2 : ( ruleXUnaryOperation ) ;
+    public final void rule__XUnaryOperation__OperandAssignment_0_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16831:1: ( ( ruleXUnaryOperation ) )
+            // InternalOXtype.g:16832:2: ( ruleXUnaryOperation )
+            {
+            // InternalOXtype.g:16832:2: ( ruleXUnaryOperation )
+            // InternalOXtype.g:16833:3: ruleXUnaryOperation
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXUnaryOperation();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XUnaryOperation__OperandAssignment_0_2"
+
+
+    // $ANTLR start "rule__XCastedExpression__TypeAssignment_1_1"
+    // InternalOXtype.g:16842:1: rule__XCastedExpression__TypeAssignment_1_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__XCastedExpression__TypeAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16846:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:16847:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:16847:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:16848:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCastedExpression__TypeAssignment_1_1"
+
+
+    // $ANTLR start "rule__XPostfixOperation__FeatureAssignment_1_0_1"
+    // InternalOXtype.g:16857:1: rule__XPostfixOperation__FeatureAssignment_1_0_1 : ( ( ruleOpPostfix ) ) ;
+    public final void rule__XPostfixOperation__FeatureAssignment_1_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16861:1: ( ( ( ruleOpPostfix ) ) )
+            // InternalOXtype.g:16862:2: ( ( ruleOpPostfix ) )
+            {
+            // InternalOXtype.g:16862:2: ( ( ruleOpPostfix ) )
+            // InternalOXtype.g:16863:3: ( ruleOpPostfix )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); 
+            }
+            // InternalOXtype.g:16864:3: ( ruleOpPostfix )
+            // InternalOXtype.g:16865:4: ruleOpPostfix
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleOpPostfix();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementOpPostfixParserRuleCall_1_0_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XPostfixOperation__FeatureAssignment_1_0_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"
+    // InternalOXtype.g:16876:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1 : ( ( '::' ) ) ;
+    public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16880:1: ( ( ( '::' ) ) )
+            // InternalOXtype.g:16881:2: ( ( '::' ) )
+            {
+            // InternalOXtype.g:16881:2: ( ( '::' ) )
+            // InternalOXtype.g:16882:3: ( '::' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); 
+            }
+            // InternalOXtype.g:16883:3: ( '::' )
+            // InternalOXtype.g:16884:4: '::'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); 
+            }
+            match(input,84,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_0_0_0_1_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"
+    // InternalOXtype.g:16895:1: rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2 : ( ( ruleFeatureCallID ) ) ;
+    public final void rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16899:1: ( ( ( ruleFeatureCallID ) ) )
+            // InternalOXtype.g:16900:2: ( ( ruleFeatureCallID ) )
+            {
+            // InternalOXtype.g:16900:2: ( ( ruleFeatureCallID ) )
+            // InternalOXtype.g:16901:3: ( ruleFeatureCallID )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); 
+            }
+            // InternalOXtype.g:16902:3: ( ruleFeatureCallID )
+            // InternalOXtype.g:16903:4: ruleFeatureCallID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleFeatureCallID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementFeatureCallIDParserRuleCall_1_0_0_0_2_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_0_0_0_2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__ValueAssignment_1_0_1"
+    // InternalOXtype.g:16914:1: rule__XMemberFeatureCall__ValueAssignment_1_0_1 : ( ruleXAssignment ) ;
+    public final void rule__XMemberFeatureCall__ValueAssignment_1_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16918:1: ( ( ruleXAssignment ) )
+            // InternalOXtype.g:16919:2: ( ruleXAssignment )
+            {
+            // InternalOXtype.g:16919:2: ( ruleXAssignment )
+            // InternalOXtype.g:16920:3: ruleXAssignment
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__ValueAssignment_1_0_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"
+    // InternalOXtype.g:16929:1: rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1 : ( ( '?.' ) ) ;
+    public final void rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16933:1: ( ( ( '?.' ) ) )
+            // InternalOXtype.g:16934:2: ( ( '?.' ) )
+            {
+            // InternalOXtype.g:16934:2: ( ( '?.' ) )
+            // InternalOXtype.g:16935:3: ( '?.' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); 
+            }
+            // InternalOXtype.g:16936:3: ( '?.' )
+            // InternalOXtype.g:16937:4: '?.'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); 
+            }
+            match(input,85,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__NullSafeAssignment_1_1_0_0_1_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"
+    // InternalOXtype.g:16948:1: rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2 : ( ( '::' ) ) ;
+    public final void rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16952:1: ( ( ( '::' ) ) )
+            // InternalOXtype.g:16953:2: ( ( '::' ) )
+            {
+            // InternalOXtype.g:16953:2: ( ( '::' ) )
+            // InternalOXtype.g:16954:3: ( '::' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); 
+            }
+            // InternalOXtype.g:16955:3: ( '::' )
+            // InternalOXtype.g:16956:4: '::'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); 
+            }
+            match(input,84,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__ExplicitStaticAssignment_1_1_0_0_1_2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"
+    // InternalOXtype.g:16967:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16971:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:16972:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:16972:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:16973:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"
+    // InternalOXtype.g:16982:1: rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:16986:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:16987:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:16987:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:16988:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__TypeArgumentsAssignment_1_1_1_2_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"
+    // InternalOXtype.g:16997:1: rule__XMemberFeatureCall__FeatureAssignment_1_1_2 : ( ( ruleIdOrSuper ) ) ;
+    public final void rule__XMemberFeatureCall__FeatureAssignment_1_1_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17001:1: ( ( ( ruleIdOrSuper ) ) )
+            // InternalOXtype.g:17002:2: ( ( ruleIdOrSuper ) )
+            {
+            // InternalOXtype.g:17002:2: ( ( ruleIdOrSuper ) )
+            // InternalOXtype.g:17003:3: ( ruleIdOrSuper )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); 
+            }
+            // InternalOXtype.g:17004:3: ( ruleIdOrSuper )
+            // InternalOXtype.g:17005:4: ruleIdOrSuper
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleIdOrSuper();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_1_1_2_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__FeatureAssignment_1_1_2"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"
+    // InternalOXtype.g:17016:1: rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0 : ( ( '(' ) ) ;
+    public final void rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17020:1: ( ( ( '(' ) ) )
+            // InternalOXtype.g:17021:2: ( ( '(' ) )
+            {
+            // InternalOXtype.g:17021:2: ( ( '(' ) )
+            // InternalOXtype.g:17022:3: ( '(' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); 
+            }
+            // InternalOXtype.g:17023:3: ( '(' )
+            // InternalOXtype.g:17024:4: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__ExplicitOperationCallAssignment_1_1_3_0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"
+    // InternalOXtype.g:17035:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 : ( ruleXShortClosure ) ;
+    public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17039:1: ( ( ruleXShortClosure ) )
+            // InternalOXtype.g:17040:2: ( ruleXShortClosure )
+            {
+            // InternalOXtype.g:17040:2: ( ruleXShortClosure )
+            // InternalOXtype.g:17041:3: ruleXShortClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXShortClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"
+    // InternalOXtype.g:17050:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0 : ( ruleXExpression ) ;
+    public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17054:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17055:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17055:2: ( ruleXExpression )
+            // InternalOXtype.g:17056:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_0"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"
+    // InternalOXtype.g:17065:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1 : ( ruleXExpression ) ;
+    public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17069:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17070:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17070:2: ( ruleXExpression )
+            // InternalOXtype.g:17071:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_1_1_1"
+
+
+    // $ANTLR start "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"
+    // InternalOXtype.g:17080:1: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 : ( ruleXClosure ) ;
+    public final void rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17084:1: ( ( ruleXClosure ) )
+            // InternalOXtype.g:17085:2: ( ruleXClosure )
+            {
+            // InternalOXtype.g:17085:2: ( ruleXClosure )
+            // InternalOXtype.g:17086:3: ruleXClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4"
+
+
+    // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_0"
+    // InternalOXtype.g:17095:1: rule__XSetLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ;
+    public final void rule__XSetLiteral__ElementsAssignment_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17099:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17100:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17100:2: ( ruleXExpression )
+            // InternalOXtype.g:17101:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_0"
+
+
+    // $ANTLR start "rule__XSetLiteral__ElementsAssignment_3_1_1"
+    // InternalOXtype.g:17110:1: rule__XSetLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ;
+    public final void rule__XSetLiteral__ElementsAssignment_3_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17114:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17115:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17115:2: ( ruleXExpression )
+            // InternalOXtype.g:17116:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSetLiteral__ElementsAssignment_3_1_1"
+
+
+    // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_0"
+    // InternalOXtype.g:17125:1: rule__XListLiteral__ElementsAssignment_3_0 : ( ruleXExpression ) ;
+    public final void rule__XListLiteral__ElementsAssignment_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17129:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17130:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17130:2: ( ruleXExpression )
+            // InternalOXtype.g:17131:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_0"
+
+
+    // $ANTLR start "rule__XListLiteral__ElementsAssignment_3_1_1"
+    // InternalOXtype.g:17140:1: rule__XListLiteral__ElementsAssignment_3_1_1 : ( ruleXExpression ) ;
+    public final void rule__XListLiteral__ElementsAssignment_3_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17144:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17145:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17145:2: ( ruleXExpression )
+            // InternalOXtype.g:17146:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XListLiteral__ElementsAssignment_3_1_1"
+
+
+    // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"
+    // InternalOXtype.g:17155:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17159:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17160:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17160:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17161:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_0"
+
+
+    // $ANTLR start "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"
+    // InternalOXtype.g:17170:1: rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17174:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17175:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17175:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17176:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__DeclaredFormalParametersAssignment_1_0_0_1_1"
+
+
+    // $ANTLR start "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"
+    // InternalOXtype.g:17185:1: rule__XClosure__ExplicitSyntaxAssignment_1_0_1 : ( ( '|' ) ) ;
+    public final void rule__XClosure__ExplicitSyntaxAssignment_1_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17189:1: ( ( ( '|' ) ) )
+            // InternalOXtype.g:17190:2: ( ( '|' ) )
+            {
+            // InternalOXtype.g:17190:2: ( ( '|' ) )
+            // InternalOXtype.g:17191:3: ( '|' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); 
+            }
+            // InternalOXtype.g:17192:3: ( '|' )
+            // InternalOXtype.g:17193:4: '|'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); 
+            }
+            match(input,86,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__ExplicitSyntaxAssignment_1_0_1"
+
+
+    // $ANTLR start "rule__XClosure__ExpressionAssignment_2"
+    // InternalOXtype.g:17204:1: rule__XClosure__ExpressionAssignment_2 : ( ruleXExpressionInClosure ) ;
+    public final void rule__XClosure__ExpressionAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17208:1: ( ( ruleXExpressionInClosure ) )
+            // InternalOXtype.g:17209:2: ( ruleXExpressionInClosure )
+            {
+            // InternalOXtype.g:17209:2: ( ruleXExpressionInClosure )
+            // InternalOXtype.g:17210:3: ruleXExpressionInClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpressionInClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XClosure__ExpressionAssignment_2"
+
+
+    // $ANTLR start "rule__XExpressionInClosure__ExpressionsAssignment_1_0"
+    // InternalOXtype.g:17219:1: rule__XExpressionInClosure__ExpressionsAssignment_1_0 : ( ruleXExpressionOrVarDeclaration ) ;
+    public final void rule__XExpressionInClosure__ExpressionsAssignment_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17223:1: ( ( ruleXExpressionOrVarDeclaration ) )
+            // InternalOXtype.g:17224:2: ( ruleXExpressionOrVarDeclaration )
+            {
+            // InternalOXtype.g:17224:2: ( ruleXExpressionOrVarDeclaration )
+            // InternalOXtype.g:17225:3: ruleXExpressionOrVarDeclaration
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpressionOrVarDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XExpressionInClosure__ExpressionsAssignment_1_0"
+
+
+    // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"
+    // InternalOXtype.g:17234:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17238:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17239:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17239:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17240:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_0"
+
+
+    // $ANTLR start "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"
+    // InternalOXtype.g:17249:1: rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17253:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17254:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17254:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17255:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__DeclaredFormalParametersAssignment_0_0_1_1_1"
+
+
+    // $ANTLR start "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"
+    // InternalOXtype.g:17264:1: rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2 : ( ( '|' ) ) ;
+    public final void rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17268:1: ( ( ( '|' ) ) )
+            // InternalOXtype.g:17269:2: ( ( '|' ) )
+            {
+            // InternalOXtype.g:17269:2: ( ( '|' ) )
+            // InternalOXtype.g:17270:3: ( '|' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); 
+            }
+            // InternalOXtype.g:17271:3: ( '|' )
+            // InternalOXtype.g:17272:4: '|'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); 
+            }
+            match(input,86,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__ExplicitSyntaxAssignment_0_0_2"
+
+
+    // $ANTLR start "rule__XShortClosure__ExpressionAssignment_1"
+    // InternalOXtype.g:17283:1: rule__XShortClosure__ExpressionAssignment_1 : ( ruleXExpression ) ;
+    public final void rule__XShortClosure__ExpressionAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17287:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17288:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17288:2: ( ruleXExpression )
+            // InternalOXtype.g:17289:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XShortClosure__ExpressionAssignment_1"
+
+
+    // $ANTLR start "rule__XIfExpression__IfAssignment_3"
+    // InternalOXtype.g:17298:1: rule__XIfExpression__IfAssignment_3 : ( ruleXExpression ) ;
+    public final void rule__XIfExpression__IfAssignment_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17302:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17303:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17303:2: ( ruleXExpression )
+            // InternalOXtype.g:17304:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__IfAssignment_3"
+
+
+    // $ANTLR start "rule__XIfExpression__ThenAssignment_5"
+    // InternalOXtype.g:17313:1: rule__XIfExpression__ThenAssignment_5 : ( ruleXExpression ) ;
+    public final void rule__XIfExpression__ThenAssignment_5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17317:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17318:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17318:2: ( ruleXExpression )
+            // InternalOXtype.g:17319:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__ThenAssignment_5"
+
+
+    // $ANTLR start "rule__XIfExpression__ElseAssignment_6_1"
+    // InternalOXtype.g:17328:1: rule__XIfExpression__ElseAssignment_6_1 : ( ruleXExpression ) ;
+    public final void rule__XIfExpression__ElseAssignment_6_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17332:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17333:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17333:2: ( ruleXExpression )
+            // InternalOXtype.g:17334:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XIfExpression__ElseAssignment_6_1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"
+    // InternalOXtype.g:17343:1: rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17347:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17348:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17348:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17349:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_0_0_0_1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_0_1"
+    // InternalOXtype.g:17358:1: rule__XSwitchExpression__SwitchAssignment_2_0_1 : ( ruleXExpression ) ;
+    public final void rule__XSwitchExpression__SwitchAssignment_2_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17362:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17363:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17363:2: ( ruleXExpression )
+            // InternalOXtype.g:17364:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_0_1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"
+    // InternalOXtype.g:17373:1: rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17377:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17378:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17378:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17379:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__DeclaredParamAssignment_2_1_0_0_0"
+
+
+    // $ANTLR start "rule__XSwitchExpression__SwitchAssignment_2_1_1"
+    // InternalOXtype.g:17388:1: rule__XSwitchExpression__SwitchAssignment_2_1_1 : ( ruleXExpression ) ;
+    public final void rule__XSwitchExpression__SwitchAssignment_2_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17392:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17393:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17393:2: ( ruleXExpression )
+            // InternalOXtype.g:17394:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__SwitchAssignment_2_1_1"
+
+
+    // $ANTLR start "rule__XSwitchExpression__CasesAssignment_4"
+    // InternalOXtype.g:17403:1: rule__XSwitchExpression__CasesAssignment_4 : ( ruleXCasePart ) ;
+    public final void rule__XSwitchExpression__CasesAssignment_4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17407:1: ( ( ruleXCasePart ) )
+            // InternalOXtype.g:17408:2: ( ruleXCasePart )
+            {
+            // InternalOXtype.g:17408:2: ( ruleXCasePart )
+            // InternalOXtype.g:17409:3: ruleXCasePart
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXCasePart();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__CasesAssignment_4"
+
+
+    // $ANTLR start "rule__XSwitchExpression__DefaultAssignment_5_2"
+    // InternalOXtype.g:17418:1: rule__XSwitchExpression__DefaultAssignment_5_2 : ( ruleXExpression ) ;
+    public final void rule__XSwitchExpression__DefaultAssignment_5_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17422:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17423:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17423:2: ( ruleXExpression )
+            // InternalOXtype.g:17424:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSwitchExpression__DefaultAssignment_5_2"
+
+
+    // $ANTLR start "rule__XCasePart__TypeGuardAssignment_1"
+    // InternalOXtype.g:17433:1: rule__XCasePart__TypeGuardAssignment_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__XCasePart__TypeGuardAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17437:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:17438:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:17438:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:17439:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__TypeGuardAssignment_1"
+
+
+    // $ANTLR start "rule__XCasePart__CaseAssignment_2_1"
+    // InternalOXtype.g:17448:1: rule__XCasePart__CaseAssignment_2_1 : ( ruleXExpression ) ;
+    public final void rule__XCasePart__CaseAssignment_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17452:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17453:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17453:2: ( ruleXExpression )
+            // InternalOXtype.g:17454:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__CaseAssignment_2_1"
+
+
+    // $ANTLR start "rule__XCasePart__ThenAssignment_3_0_1"
+    // InternalOXtype.g:17463:1: rule__XCasePart__ThenAssignment_3_0_1 : ( ruleXExpression ) ;
+    public final void rule__XCasePart__ThenAssignment_3_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17467:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17468:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17468:2: ( ruleXExpression )
+            // InternalOXtype.g:17469:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__ThenAssignment_3_0_1"
+
+
+    // $ANTLR start "rule__XCasePart__FallThroughAssignment_3_1"
+    // InternalOXtype.g:17478:1: rule__XCasePart__FallThroughAssignment_3_1 : ( ( ',' ) ) ;
+    public final void rule__XCasePart__FallThroughAssignment_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17482:1: ( ( ( ',' ) ) )
+            // InternalOXtype.g:17483:2: ( ( ',' ) )
+            {
+            // InternalOXtype.g:17483:2: ( ( ',' ) )
+            // InternalOXtype.g:17484:3: ( ',' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); 
+            }
+            // InternalOXtype.g:17485:3: ( ',' )
+            // InternalOXtype.g:17486:4: ','
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); 
+            }
+            match(input,55,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCasePart__FallThroughAssignment_3_1"
+
+
+    // $ANTLR start "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"
+    // InternalOXtype.g:17497:1: rule__XForLoopExpression__DeclaredParamAssignment_0_0_3 : ( ruleJvmFormalParameter ) ;
+    public final void rule__XForLoopExpression__DeclaredParamAssignment_0_0_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17501:1: ( ( ruleJvmFormalParameter ) )
+            // InternalOXtype.g:17502:2: ( ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:17502:2: ( ruleJvmFormalParameter )
+            // InternalOXtype.g:17503:3: ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__DeclaredParamAssignment_0_0_3"
+
+
+    // $ANTLR start "rule__XForLoopExpression__ForExpressionAssignment_1"
+    // InternalOXtype.g:17512:1: rule__XForLoopExpression__ForExpressionAssignment_1 : ( ruleXExpression ) ;
+    public final void rule__XForLoopExpression__ForExpressionAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17516:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17517:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17517:2: ( ruleXExpression )
+            // InternalOXtype.g:17518:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__ForExpressionAssignment_1"
+
+
+    // $ANTLR start "rule__XForLoopExpression__EachExpressionAssignment_3"
+    // InternalOXtype.g:17527:1: rule__XForLoopExpression__EachExpressionAssignment_3 : ( ruleXExpression ) ;
+    public final void rule__XForLoopExpression__EachExpressionAssignment_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17531:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17532:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17532:2: ( ruleXExpression )
+            // InternalOXtype.g:17533:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XForLoopExpression__EachExpressionAssignment_3"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"
+    // InternalOXtype.g:17542:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0 : ( ruleXExpressionOrVarDeclaration ) ;
+    public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17546:1: ( ( ruleXExpressionOrVarDeclaration ) )
+            // InternalOXtype.g:17547:2: ( ruleXExpressionOrVarDeclaration )
+            {
+            // InternalOXtype.g:17547:2: ( ruleXExpressionOrVarDeclaration )
+            // InternalOXtype.g:17548:3: ruleXExpressionOrVarDeclaration
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpressionOrVarDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"
+    // InternalOXtype.g:17557:1: rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1 : ( ruleXExpressionOrVarDeclaration ) ;
+    public final void rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17561:1: ( ( ruleXExpressionOrVarDeclaration ) )
+            // InternalOXtype.g:17562:2: ( ruleXExpressionOrVarDeclaration )
+            {
+            // InternalOXtype.g:17562:2: ( ruleXExpressionOrVarDeclaration )
+            // InternalOXtype.g:17563:3: ruleXExpressionOrVarDeclaration
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpressionOrVarDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__InitExpressionsAssignment_3_1_1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__ExpressionAssignment_5"
+    // InternalOXtype.g:17572:1: rule__XBasicForLoopExpression__ExpressionAssignment_5 : ( ruleXExpression ) ;
+    public final void rule__XBasicForLoopExpression__ExpressionAssignment_5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17576:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17577:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17577:2: ( ruleXExpression )
+            // InternalOXtype.g:17578:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__ExpressionAssignment_5"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"
+    // InternalOXtype.g:17587:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0 : ( ruleXExpression ) ;
+    public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17591:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17592:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17592:2: ( ruleXExpression )
+            // InternalOXtype.g:17593:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_0"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"
+    // InternalOXtype.g:17602:1: rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1 : ( ruleXExpression ) ;
+    public final void rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17606:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17607:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17607:2: ( ruleXExpression )
+            // InternalOXtype.g:17608:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__UpdateExpressionsAssignment_7_1_1"
+
+
+    // $ANTLR start "rule__XBasicForLoopExpression__EachExpressionAssignment_9"
+    // InternalOXtype.g:17617:1: rule__XBasicForLoopExpression__EachExpressionAssignment_9 : ( ruleXExpression ) ;
+    public final void rule__XBasicForLoopExpression__EachExpressionAssignment_9() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17621:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17622:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17622:2: ( ruleXExpression )
+            // InternalOXtype.g:17623:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBasicForLoopExpression__EachExpressionAssignment_9"
+
+
+    // $ANTLR start "rule__XWhileExpression__PredicateAssignment_3"
+    // InternalOXtype.g:17632:1: rule__XWhileExpression__PredicateAssignment_3 : ( ruleXExpression ) ;
+    public final void rule__XWhileExpression__PredicateAssignment_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17636:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17637:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17637:2: ( ruleXExpression )
+            // InternalOXtype.g:17638:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__PredicateAssignment_3"
+
+
+    // $ANTLR start "rule__XWhileExpression__BodyAssignment_5"
+    // InternalOXtype.g:17647:1: rule__XWhileExpression__BodyAssignment_5 : ( ruleXExpression ) ;
+    public final void rule__XWhileExpression__BodyAssignment_5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17651:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17652:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17652:2: ( ruleXExpression )
+            // InternalOXtype.g:17653:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XWhileExpression__BodyAssignment_5"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__BodyAssignment_2"
+    // InternalOXtype.g:17662:1: rule__XDoWhileExpression__BodyAssignment_2 : ( ruleXExpression ) ;
+    public final void rule__XDoWhileExpression__BodyAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17666:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17667:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17667:2: ( ruleXExpression )
+            // InternalOXtype.g:17668:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__BodyAssignment_2"
+
+
+    // $ANTLR start "rule__XDoWhileExpression__PredicateAssignment_5"
+    // InternalOXtype.g:17677:1: rule__XDoWhileExpression__PredicateAssignment_5 : ( ruleXExpression ) ;
+    public final void rule__XDoWhileExpression__PredicateAssignment_5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17681:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17682:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17682:2: ( ruleXExpression )
+            // InternalOXtype.g:17683:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XDoWhileExpression__PredicateAssignment_5"
+
+
+    // $ANTLR start "rule__XBlockExpression__ExpressionsAssignment_2_0"
+    // InternalOXtype.g:17692:1: rule__XBlockExpression__ExpressionsAssignment_2_0 : ( ruleXExpressionOrVarDeclaration ) ;
+    public final void rule__XBlockExpression__ExpressionsAssignment_2_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17696:1: ( ( ruleXExpressionOrVarDeclaration ) )
+            // InternalOXtype.g:17697:2: ( ruleXExpressionOrVarDeclaration )
+            {
+            // InternalOXtype.g:17697:2: ( ruleXExpressionOrVarDeclaration )
+            // InternalOXtype.g:17698:3: ruleXExpressionOrVarDeclaration
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpressionOrVarDeclaration();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBlockExpression__ExpressionsAssignment_2_0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__WriteableAssignment_1_0"
+    // InternalOXtype.g:17707:1: rule__XVariableDeclaration__WriteableAssignment_1_0 : ( ( 'var' ) ) ;
+    public final void rule__XVariableDeclaration__WriteableAssignment_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17711:1: ( ( ( 'var' ) ) )
+            // InternalOXtype.g:17712:2: ( ( 'var' ) )
+            {
+            // InternalOXtype.g:17712:2: ( ( 'var' ) )
+            // InternalOXtype.g:17713:3: ( 'var' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); 
+            }
+            // InternalOXtype.g:17714:3: ( 'var' )
+            // InternalOXtype.g:17715:4: 'var'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); 
+            }
+            match(input,87,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__WriteableAssignment_1_0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"
+    // InternalOXtype.g:17726:1: rule__XVariableDeclaration__TypeAssignment_2_0_0_0 : ( ruleJvmTypeReference ) ;
+    public final void rule__XVariableDeclaration__TypeAssignment_2_0_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17730:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:17731:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:17731:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:17732:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__TypeAssignment_2_0_0_0"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_0_0_1"
+    // InternalOXtype.g:17741:1: rule__XVariableDeclaration__NameAssignment_2_0_0_1 : ( ruleValidID ) ;
+    public final void rule__XVariableDeclaration__NameAssignment_2_0_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17745:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:17746:2: ( ruleValidID )
+            {
+            // InternalOXtype.g:17746:2: ( ruleValidID )
+            // InternalOXtype.g:17747:3: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_0_0_1"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__NameAssignment_2_1"
+    // InternalOXtype.g:17756:1: rule__XVariableDeclaration__NameAssignment_2_1 : ( ruleValidID ) ;
+    public final void rule__XVariableDeclaration__NameAssignment_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17760:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:17761:2: ( ruleValidID )
+            {
+            // InternalOXtype.g:17761:2: ( ruleValidID )
+            // InternalOXtype.g:17762:3: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__NameAssignment_2_1"
+
+
+    // $ANTLR start "rule__XVariableDeclaration__RightAssignment_3_1"
+    // InternalOXtype.g:17771:1: rule__XVariableDeclaration__RightAssignment_3_1 : ( ruleXExpression ) ;
+    public final void rule__XVariableDeclaration__RightAssignment_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17775:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17776:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17776:2: ( ruleXExpression )
+            // InternalOXtype.g:17777:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XVariableDeclaration__RightAssignment_3_1"
+
+
+    // $ANTLR start "rule__JvmFormalParameter__ParameterTypeAssignment_0"
+    // InternalOXtype.g:17786:1: rule__JvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ;
+    public final void rule__JvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17790:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:17791:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:17791:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:17792:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmFormalParameter__ParameterTypeAssignment_0"
+
+
+    // $ANTLR start "rule__JvmFormalParameter__NameAssignment_1"
+    // InternalOXtype.g:17801:1: rule__JvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ;
+    public final void rule__JvmFormalParameter__NameAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17805:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:17806:2: ( ruleValidID )
+            {
+            // InternalOXtype.g:17806:2: ( ruleValidID )
+            // InternalOXtype.g:17807:3: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmFormalParameter__NameAssignment_1"
+
+
+    // $ANTLR start "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"
+    // InternalOXtype.g:17816:1: rule__FullJvmFormalParameter__ParameterTypeAssignment_0 : ( ruleJvmTypeReference ) ;
+    public final void rule__FullJvmFormalParameter__ParameterTypeAssignment_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17820:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:17821:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:17821:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:17822:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FullJvmFormalParameter__ParameterTypeAssignment_0"
+
+
+    // $ANTLR start "rule__FullJvmFormalParameter__NameAssignment_1"
+    // InternalOXtype.g:17831:1: rule__FullJvmFormalParameter__NameAssignment_1 : ( ruleValidID ) ;
+    public final void rule__FullJvmFormalParameter__NameAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17835:1: ( ( ruleValidID ) )
+            // InternalOXtype.g:17836:2: ( ruleValidID )
+            {
+            // InternalOXtype.g:17836:2: ( ruleValidID )
+            // InternalOXtype.g:17837:3: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__FullJvmFormalParameter__NameAssignment_1"
+
+
+    // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_1"
+    // InternalOXtype.g:17846:1: rule__XFeatureCall__TypeArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__XFeatureCall__TypeArgumentsAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17850:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:17851:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:17851:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:17852:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_1"
+
+
+    // $ANTLR start "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"
+    // InternalOXtype.g:17861:1: rule__XFeatureCall__TypeArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__XFeatureCall__TypeArgumentsAssignment_1_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17865:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:17866:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:17866:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:17867:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__TypeArgumentsAssignment_1_2_1"
+
+
+    // $ANTLR start "rule__XFeatureCall__FeatureAssignment_2"
+    // InternalOXtype.g:17876:1: rule__XFeatureCall__FeatureAssignment_2 : ( ( ruleIdOrSuper ) ) ;
+    public final void rule__XFeatureCall__FeatureAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17880:1: ( ( ( ruleIdOrSuper ) ) )
+            // InternalOXtype.g:17881:2: ( ( ruleIdOrSuper ) )
+            {
+            // InternalOXtype.g:17881:2: ( ( ruleIdOrSuper ) )
+            // InternalOXtype.g:17882:3: ( ruleIdOrSuper )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); 
+            }
+            // InternalOXtype.g:17883:3: ( ruleIdOrSuper )
+            // InternalOXtype.g:17884:4: ruleIdOrSuper
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleIdOrSuper();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementIdOrSuperParserRuleCall_2_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__FeatureAssignment_2"
+
+
+    // $ANTLR start "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"
+    // InternalOXtype.g:17895:1: rule__XFeatureCall__ExplicitOperationCallAssignment_3_0 : ( ( '(' ) ) ;
+    public final void rule__XFeatureCall__ExplicitOperationCallAssignment_3_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17899:1: ( ( ( '(' ) ) )
+            // InternalOXtype.g:17900:2: ( ( '(' ) )
+            {
+            // InternalOXtype.g:17900:2: ( ( '(' ) )
+            // InternalOXtype.g:17901:3: ( '(' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); 
+            }
+            // InternalOXtype.g:17902:3: ( '(' )
+            // InternalOXtype.g:17903:4: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__ExplicitOperationCallAssignment_3_0"
+
+
+    // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"
+    // InternalOXtype.g:17914:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 : ( ruleXShortClosure ) ;
+    public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17918:1: ( ( ruleXShortClosure ) )
+            // InternalOXtype.g:17919:2: ( ruleXShortClosure )
+            {
+            // InternalOXtype.g:17919:2: ( ruleXShortClosure )
+            // InternalOXtype.g:17920:3: ruleXShortClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXShortClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0"
+
+
+    // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"
+    // InternalOXtype.g:17929:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0 : ( ruleXExpression ) ;
+    public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17933:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17934:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17934:2: ( ruleXExpression )
+            // InternalOXtype.g:17935:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_0"
+
+
+    // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"
+    // InternalOXtype.g:17944:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1 : ( ruleXExpression ) ;
+    public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17948:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:17949:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:17949:2: ( ruleXExpression )
+            // InternalOXtype.g:17950:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_1_1_1"
+
+
+    // $ANTLR start "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"
+    // InternalOXtype.g:17959:1: rule__XFeatureCall__FeatureCallArgumentsAssignment_4 : ( ruleXClosure ) ;
+    public final void rule__XFeatureCall__FeatureCallArgumentsAssignment_4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17963:1: ( ( ruleXClosure ) )
+            // InternalOXtype.g:17964:2: ( ruleXClosure )
+            {
+            // InternalOXtype.g:17964:2: ( ruleXClosure )
+            // InternalOXtype.g:17965:3: ruleXClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFeatureCall__FeatureCallArgumentsAssignment_4"
+
+
+    // $ANTLR start "rule__XConstructorCall__ConstructorAssignment_2"
+    // InternalOXtype.g:17974:1: rule__XConstructorCall__ConstructorAssignment_2 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__XConstructorCall__ConstructorAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17978:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalOXtype.g:17979:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalOXtype.g:17979:2: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:17980:3: ( ruleQualifiedName )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); 
+            }
+            // InternalOXtype.g:17981:3: ( ruleQualifiedName )
+            // InternalOXtype.g:17982:4: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorQualifiedNameParserRuleCall_2_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__ConstructorAssignment_2"
+
+
+    // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_1"
+    // InternalOXtype.g:17993:1: rule__XConstructorCall__TypeArgumentsAssignment_3_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__XConstructorCall__TypeArgumentsAssignment_3_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:17997:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:17998:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:17998:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:17999:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_1"
+
+
+    // $ANTLR start "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"
+    // InternalOXtype.g:18008:1: rule__XConstructorCall__TypeArgumentsAssignment_3_2_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__XConstructorCall__TypeArgumentsAssignment_3_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18012:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:18013:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:18013:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:18014:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__TypeArgumentsAssignment_3_2_1"
+
+
+    // $ANTLR start "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"
+    // InternalOXtype.g:18023:1: rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0 : ( ( '(' ) ) ;
+    public final void rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18027:1: ( ( ( '(' ) ) )
+            // InternalOXtype.g:18028:2: ( ( '(' ) )
+            {
+            // InternalOXtype.g:18028:2: ( ( '(' ) )
+            // InternalOXtype.g:18029:3: ( '(' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); 
+            }
+            // InternalOXtype.g:18030:3: ( '(' )
+            // InternalOXtype.g:18031:4: '('
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); 
+            }
+            match(input,53,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__ExplicitConstructorCallAssignment_4_0"
+
+
+    // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_0"
+    // InternalOXtype.g:18042:1: rule__XConstructorCall__ArgumentsAssignment_4_1_0 : ( ruleXShortClosure ) ;
+    public final void rule__XConstructorCall__ArgumentsAssignment_4_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18046:1: ( ( ruleXShortClosure ) )
+            // InternalOXtype.g:18047:2: ( ruleXShortClosure )
+            {
+            // InternalOXtype.g:18047:2: ( ruleXShortClosure )
+            // InternalOXtype.g:18048:3: ruleXShortClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXShortClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_0"
+
+
+    // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"
+    // InternalOXtype.g:18057:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_0 : ( ruleXExpression ) ;
+    public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18061:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18062:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18062:2: ( ruleXExpression )
+            // InternalOXtype.g:18063:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_0"
+
+
+    // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"
+    // InternalOXtype.g:18072:1: rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1 : ( ruleXExpression ) ;
+    public final void rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18076:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18077:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18077:2: ( ruleXExpression )
+            // InternalOXtype.g:18078:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_4_1_1_1_1"
+
+
+    // $ANTLR start "rule__XConstructorCall__ArgumentsAssignment_5"
+    // InternalOXtype.g:18087:1: rule__XConstructorCall__ArgumentsAssignment_5 : ( ruleXClosure ) ;
+    public final void rule__XConstructorCall__ArgumentsAssignment_5() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18091:1: ( ( ruleXClosure ) )
+            // InternalOXtype.g:18092:2: ( ruleXClosure )
+            {
+            // InternalOXtype.g:18092:2: ( ruleXClosure )
+            // InternalOXtype.g:18093:3: ruleXClosure
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXClosure();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XConstructorCall__ArgumentsAssignment_5"
+
+
+    // $ANTLR start "rule__XBooleanLiteral__IsTrueAssignment_1_1"
+    // InternalOXtype.g:18102:1: rule__XBooleanLiteral__IsTrueAssignment_1_1 : ( ( 'true' ) ) ;
+    public final void rule__XBooleanLiteral__IsTrueAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18106:1: ( ( ( 'true' ) ) )
+            // InternalOXtype.g:18107:2: ( ( 'true' ) )
+            {
+            // InternalOXtype.g:18107:2: ( ( 'true' ) )
+            // InternalOXtype.g:18108:3: ( 'true' )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
+            }
+            // InternalOXtype.g:18109:3: ( 'true' )
+            // InternalOXtype.g:18110:4: 'true'
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
+            }
+            match(input,88,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XBooleanLiteral__IsTrueAssignment_1_1"
+
+
+    // $ANTLR start "rule__XNumberLiteral__ValueAssignment_1"
+    // InternalOXtype.g:18121:1: rule__XNumberLiteral__ValueAssignment_1 : ( ruleNumber ) ;
+    public final void rule__XNumberLiteral__ValueAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18125:1: ( ( ruleNumber ) )
+            // InternalOXtype.g:18126:2: ( ruleNumber )
+            {
+            // InternalOXtype.g:18126:2: ( ruleNumber )
+            // InternalOXtype.g:18127:3: ruleNumber
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleNumber();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XNumberLiteral__ValueAssignment_1"
+
+
+    // $ANTLR start "rule__XStringLiteral__ValueAssignment_1"
+    // InternalOXtype.g:18136:1: rule__XStringLiteral__ValueAssignment_1 : ( RULE_STRING ) ;
+    public final void rule__XStringLiteral__ValueAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18140:1: ( ( RULE_STRING ) )
+            // InternalOXtype.g:18141:2: ( RULE_STRING )
+            {
+            // InternalOXtype.g:18141:2: ( RULE_STRING )
+            // InternalOXtype.g:18142:3: RULE_STRING
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); 
+            }
+            match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XStringLiteral__ValueAssignment_1"
+
+
+    // $ANTLR start "rule__XTypeLiteral__TypeAssignment_3"
+    // InternalOXtype.g:18151:1: rule__XTypeLiteral__TypeAssignment_3 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__XTypeLiteral__TypeAssignment_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18155:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalOXtype.g:18156:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalOXtype.g:18156:2: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:18157:3: ( ruleQualifiedName )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); 
+            }
+            // InternalOXtype.g:18158:3: ( ruleQualifiedName )
+            // InternalOXtype.g:18159:4: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeQualifiedNameParserRuleCall_3_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__TypeAssignment_3"
+
+
+    // $ANTLR start "rule__XTypeLiteral__ArrayDimensionsAssignment_4"
+    // InternalOXtype.g:18170:1: rule__XTypeLiteral__ArrayDimensionsAssignment_4 : ( ruleArrayBrackets ) ;
+    public final void rule__XTypeLiteral__ArrayDimensionsAssignment_4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18174:1: ( ( ruleArrayBrackets ) )
+            // InternalOXtype.g:18175:2: ( ruleArrayBrackets )
+            {
+            // InternalOXtype.g:18175:2: ( ruleArrayBrackets )
+            // InternalOXtype.g:18176:3: ruleArrayBrackets
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleArrayBrackets();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTypeLiteral__ArrayDimensionsAssignment_4"
+
+
+    // $ANTLR start "rule__XThrowExpression__ExpressionAssignment_2"
+    // InternalOXtype.g:18185:1: rule__XThrowExpression__ExpressionAssignment_2 : ( ruleXExpression ) ;
+    public final void rule__XThrowExpression__ExpressionAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18189:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18190:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18190:2: ( ruleXExpression )
+            // InternalOXtype.g:18191:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XThrowExpression__ExpressionAssignment_2"
+
+
+    // $ANTLR start "rule__XReturnExpression__ExpressionAssignment_2"
+    // InternalOXtype.g:18200:1: rule__XReturnExpression__ExpressionAssignment_2 : ( ruleXExpression ) ;
+    public final void rule__XReturnExpression__ExpressionAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18204:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18205:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18205:2: ( ruleXExpression )
+            // InternalOXtype.g:18206:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XReturnExpression__ExpressionAssignment_2"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"
+    // InternalOXtype.g:18215:1: rule__XTryCatchFinallyExpression__ExpressionAssignment_2 : ( ruleXExpression ) ;
+    public final void rule__XTryCatchFinallyExpression__ExpressionAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18219:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18220:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18220:2: ( ruleXExpression )
+            // InternalOXtype.g:18221:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__ExpressionAssignment_2"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"
+    // InternalOXtype.g:18230:1: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 : ( ruleXCatchClause ) ;
+    public final void rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18234:1: ( ( ruleXCatchClause ) )
+            // InternalOXtype.g:18235:2: ( ruleXCatchClause )
+            {
+            // InternalOXtype.g:18235:2: ( ruleXCatchClause )
+            // InternalOXtype.g:18236:3: ruleXCatchClause
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXCatchClause();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"
+    // InternalOXtype.g:18245:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1 : ( ruleXExpression ) ;
+    public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18249:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18250:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18250:2: ( ruleXExpression )
+            // InternalOXtype.g:18251:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_0_1_1"
+
+
+    // $ANTLR start "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"
+    // InternalOXtype.g:18260:1: rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1 : ( ruleXExpression ) ;
+    public final void rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18264:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18265:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18265:2: ( ruleXExpression )
+            // InternalOXtype.g:18266:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XTryCatchFinallyExpression__FinallyExpressionAssignment_3_1_1"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__ParamAssignment_1"
+    // InternalOXtype.g:18275:1: rule__XSynchronizedExpression__ParamAssignment_1 : ( ruleXExpression ) ;
+    public final void rule__XSynchronizedExpression__ParamAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18279:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18280:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18280:2: ( ruleXExpression )
+            // InternalOXtype.g:18281:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__ParamAssignment_1"
+
+
+    // $ANTLR start "rule__XSynchronizedExpression__ExpressionAssignment_3"
+    // InternalOXtype.g:18290:1: rule__XSynchronizedExpression__ExpressionAssignment_3 : ( ruleXExpression ) ;
+    public final void rule__XSynchronizedExpression__ExpressionAssignment_3() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18294:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18295:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18295:2: ( ruleXExpression )
+            // InternalOXtype.g:18296:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XSynchronizedExpression__ExpressionAssignment_3"
+
+
+    // $ANTLR start "rule__XCatchClause__DeclaredParamAssignment_2"
+    // InternalOXtype.g:18305:1: rule__XCatchClause__DeclaredParamAssignment_2 : ( ruleFullJvmFormalParameter ) ;
+    public final void rule__XCatchClause__DeclaredParamAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18309:1: ( ( ruleFullJvmFormalParameter ) )
+            // InternalOXtype.g:18310:2: ( ruleFullJvmFormalParameter )
+            {
+            // InternalOXtype.g:18310:2: ( ruleFullJvmFormalParameter )
+            // InternalOXtype.g:18311:3: ruleFullJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleFullJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__DeclaredParamAssignment_2"
+
+
+    // $ANTLR start "rule__XCatchClause__ExpressionAssignment_4"
+    // InternalOXtype.g:18320:1: rule__XCatchClause__ExpressionAssignment_4 : ( ruleXExpression ) ;
+    public final void rule__XCatchClause__ExpressionAssignment_4() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18324:1: ( ( ruleXExpression ) )
+            // InternalOXtype.g:18325:2: ( ruleXExpression )
+            {
+            // InternalOXtype.g:18325:2: ( ruleXExpression )
+            // InternalOXtype.g:18326:3: ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XCatchClause__ExpressionAssignment_4"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"
+    // InternalOXtype.g:18335:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0 : ( ruleJvmTypeReference ) ;
+    public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18339:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18340:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18340:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18341:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_0"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"
+    // InternalOXtype.g:18350:1: rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18354:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18355:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18355:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18356:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__ParamTypesAssignment_0_1_1_1"
+
+
+    // $ANTLR start "rule__XFunctionTypeRef__ReturnTypeAssignment_2"
+    // InternalOXtype.g:18365:1: rule__XFunctionTypeRef__ReturnTypeAssignment_2 : ( ruleJvmTypeReference ) ;
+    public final void rule__XFunctionTypeRef__ReturnTypeAssignment_2() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18369:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18370:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18370:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18371:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__XFunctionTypeRef__ReturnTypeAssignment_2"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_0"
+    // InternalOXtype.g:18380:1: rule__JvmParameterizedTypeReference__TypeAssignment_0 : ( ( ruleQualifiedName ) ) ;
+    public final void rule__JvmParameterizedTypeReference__TypeAssignment_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18384:1: ( ( ( ruleQualifiedName ) ) )
+            // InternalOXtype.g:18385:2: ( ( ruleQualifiedName ) )
+            {
+            // InternalOXtype.g:18385:2: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:18386:3: ( ruleQualifiedName )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); 
+            }
+            // InternalOXtype.g:18387:3: ( ruleQualifiedName )
+            // InternalOXtype.g:18388:4: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeQualifiedNameParserRuleCall_0_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_0"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"
+    // InternalOXtype.g:18399:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18403:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:18404:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:18404:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:18405:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"
+    // InternalOXtype.g:18414:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18418:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:18419:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:18419:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:18420:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_2_1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"
+    // InternalOXtype.g:18429:1: rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1 : ( ( ruleValidID ) ) ;
+    public final void rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18433:1: ( ( ( ruleValidID ) ) )
+            // InternalOXtype.g:18434:2: ( ( ruleValidID ) )
+            {
+            // InternalOXtype.g:18434:2: ( ( ruleValidID ) )
+            // InternalOXtype.g:18435:3: ( ruleValidID )
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); 
+            }
+            // InternalOXtype.g:18436:3: ( ruleValidID )
+            // InternalOXtype.g:18437:4: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeValidIDParserRuleCall_1_4_1_0_1()); 
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__TypeAssignment_1_4_1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"
+    // InternalOXtype.g:18448:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18452:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:18453:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:18453:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:18454:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_1"
+
+
+    // $ANTLR start "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"
+    // InternalOXtype.g:18463:1: rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1 : ( ruleJvmArgumentTypeReference ) ;
+    public final void rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18467:1: ( ( ruleJvmArgumentTypeReference ) )
+            // InternalOXtype.g:18468:2: ( ruleJvmArgumentTypeReference )
+            {
+            // InternalOXtype.g:18468:2: ( ruleJvmArgumentTypeReference )
+            // InternalOXtype.g:18469:3: ruleJvmArgumentTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmParameterizedTypeReference__ArgumentsAssignment_1_4_2_2_1"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"
+    // InternalOXtype.g:18478:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0 : ( ruleJvmUpperBound ) ;
+    public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18482:1: ( ( ruleJvmUpperBound ) )
+            // InternalOXtype.g:18483:2: ( ruleJvmUpperBound )
+            {
+            // InternalOXtype.g:18483:2: ( ruleJvmUpperBound )
+            // InternalOXtype.g:18484:3: ruleJvmUpperBound
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmUpperBound();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_0"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"
+    // InternalOXtype.g:18493:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1 : ( ruleJvmUpperBoundAnded ) ;
+    public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18497:1: ( ( ruleJvmUpperBoundAnded ) )
+            // InternalOXtype.g:18498:2: ( ruleJvmUpperBoundAnded )
+            {
+            // InternalOXtype.g:18498:2: ( ruleJvmUpperBoundAnded )
+            // InternalOXtype.g:18499:3: ruleJvmUpperBoundAnded
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmUpperBoundAnded();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_0_1"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"
+    // InternalOXtype.g:18508:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0 : ( ruleJvmLowerBound ) ;
+    public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18512:1: ( ( ruleJvmLowerBound ) )
+            // InternalOXtype.g:18513:2: ( ruleJvmLowerBound )
+            {
+            // InternalOXtype.g:18513:2: ( ruleJvmLowerBound )
+            // InternalOXtype.g:18514:3: ruleJvmLowerBound
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmLowerBound();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_0"
+
+
+    // $ANTLR start "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"
+    // InternalOXtype.g:18523:1: rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1 : ( ruleJvmLowerBoundAnded ) ;
+    public final void rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18527:1: ( ( ruleJvmLowerBoundAnded ) )
+            // InternalOXtype.g:18528:2: ( ruleJvmLowerBoundAnded )
+            {
+            // InternalOXtype.g:18528:2: ( ruleJvmLowerBoundAnded )
+            // InternalOXtype.g:18529:3: ruleJvmLowerBoundAnded
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmLowerBoundAnded();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmWildcardTypeReference__ConstraintsAssignment_2_1_1"
+
+
+    // $ANTLR start "rule__JvmUpperBound__TypeReferenceAssignment_1"
+    // InternalOXtype.g:18538:1: rule__JvmUpperBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__JvmUpperBound__TypeReferenceAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18542:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18543:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18543:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18544:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBound__TypeReferenceAssignment_1"
+
+
+    // $ANTLR start "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"
+    // InternalOXtype.g:18553:1: rule__JvmUpperBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__JvmUpperBoundAnded__TypeReferenceAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18557:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18558:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18558:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18559:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmUpperBoundAnded__TypeReferenceAssignment_1"
+
+
+    // $ANTLR start "rule__JvmLowerBound__TypeReferenceAssignment_1"
+    // InternalOXtype.g:18568:1: rule__JvmLowerBound__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__JvmLowerBound__TypeReferenceAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18572:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18573:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18573:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18574:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBound__TypeReferenceAssignment_1"
+
+
+    // $ANTLR start "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"
+    // InternalOXtype.g:18583:1: rule__JvmLowerBoundAnded__TypeReferenceAssignment_1 : ( ruleJvmTypeReference ) ;
+    public final void rule__JvmLowerBoundAnded__TypeReferenceAssignment_1() throws RecognitionException {
+
+        		int stackSize = keepStackSize();
+        	
+        try {
+            // InternalOXtype.g:18587:1: ( ( ruleJvmTypeReference ) )
+            // InternalOXtype.g:18588:2: ( ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:18588:2: ( ruleJvmTypeReference )
+            // InternalOXtype.g:18589:3: ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+               before(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+            pushFollow(FOLLOW_2);
+            ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return ;
+            if ( state.backtracking==0 ) {
+               after(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0()); 
+            }
+
+            }
+
+
+            }
+
+        }
+        catch (RecognitionException re) {
+            reportError(re);
+            recover(input,re);
+        }
+        finally {
+
+            	restoreStackSize(stackSize);
+
+        }
+        return ;
+    }
+    // $ANTLR end "rule__JvmLowerBoundAnded__TypeReferenceAssignment_1"
+
+    // $ANTLR start synpred6_InternalOXtype
+    public final void synpred6_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2127:2: ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) )
+        // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+        {
+        // InternalOXtype.g:2127:2: ( ( rule__XAnnotation__Group_3_1_0__0 ) )
+        // InternalOXtype.g:2128:3: ( rule__XAnnotation__Group_3_1_0__0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXAnnotationAccess().getGroup_3_1_0()); 
+        }
+        // InternalOXtype.g:2129:3: ( rule__XAnnotation__Group_3_1_0__0 )
+        // InternalOXtype.g:2129:4: rule__XAnnotation__Group_3_1_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XAnnotation__Group_3_1_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred6_InternalOXtype
+
+    // $ANTLR start synpred7_InternalOXtype
+    public final void synpred7_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2148:2: ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) )
+        // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+        {
+        // InternalOXtype.g:2148:2: ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) )
+        // InternalOXtype.g:2149:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getGroup_0()); 
+        }
+        // InternalOXtype.g:2150:3: ( rule__XAnnotationElementValueOrCommaList__Group_0__0 )
+        // InternalOXtype.g:2150:4: rule__XAnnotationElementValueOrCommaList__Group_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XAnnotationElementValueOrCommaList__Group_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred7_InternalOXtype
+
+    // $ANTLR start synpred8_InternalOXtype
+    public final void synpred8_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2169:2: ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) )
+        // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+        {
+        // InternalOXtype.g:2169:2: ( ( rule__XAnnotationElementValue__Group_0__0 ) )
+        // InternalOXtype.g:2170:3: ( rule__XAnnotationElementValue__Group_0__0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXAnnotationElementValueAccess().getGroup_0()); 
+        }
+        // InternalOXtype.g:2171:3: ( rule__XAnnotationElementValue__Group_0__0 )
+        // InternalOXtype.g:2171:4: rule__XAnnotationElementValue__Group_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XAnnotationElementValue__Group_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred8_InternalOXtype
+
+    // $ANTLR start synpred33_InternalOXtype
+    public final void synpred33_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2454:2: ( ( ( rule__OpOther__Group_6_1_0__0 ) ) )
+        // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+        {
+        // InternalOXtype.g:2454:2: ( ( rule__OpOther__Group_6_1_0__0 ) )
+        // InternalOXtype.g:2455:3: ( rule__OpOther__Group_6_1_0__0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getOpOtherAccess().getGroup_6_1_0()); 
+        }
+        // InternalOXtype.g:2456:3: ( rule__OpOther__Group_6_1_0__0 )
+        // InternalOXtype.g:2456:4: rule__OpOther__Group_6_1_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__OpOther__Group_6_1_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred33_InternalOXtype
+
+    // $ANTLR start synpred34_InternalOXtype
+    public final void synpred34_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2460:2: ( ( '<' ) )
+        // InternalOXtype.g:2460:2: ( '<' )
+        {
+        // InternalOXtype.g:2460:2: ( '<' )
+        // InternalOXtype.g:2461:3: '<'
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1()); 
+        }
+        match(input,27,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred34_InternalOXtype
+
+    // $ANTLR start synpred47_InternalOXtype
+    public final void synpred47_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2673:2: ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) )
+        // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+        {
+        // InternalOXtype.g:2673:2: ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) )
+        // InternalOXtype.g:2674:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsAssignment_1_1_3_1_0()); 
+        }
+        // InternalOXtype.g:2675:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 )
+        // InternalOXtype.g:2675:4: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred47_InternalOXtype
+
+    // $ANTLR start synpred55_InternalOXtype
+    public final void synpred55_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2736:2: ( ( ( ruleXForLoopExpression ) ) )
+        // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+        {
+        // InternalOXtype.g:2736:2: ( ( ruleXForLoopExpression ) )
+        // InternalOXtype.g:2737:3: ( ruleXForLoopExpression )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7()); 
+        }
+        // InternalOXtype.g:2738:3: ( ruleXForLoopExpression )
+        // InternalOXtype.g:2738:4: ruleXForLoopExpression
+        {
+        pushFollow(FOLLOW_2);
+        ruleXForLoopExpression();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred55_InternalOXtype
+
+    // $ANTLR start synpred56_InternalOXtype
+    public final void synpred56_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2742:2: ( ( ruleXBasicForLoopExpression ) )
+        // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+        {
+        // InternalOXtype.g:2742:2: ( ruleXBasicForLoopExpression )
+        // InternalOXtype.g:2743:3: ruleXBasicForLoopExpression
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8()); 
+        }
+        pushFollow(FOLLOW_2);
+        ruleXBasicForLoopExpression();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred56_InternalOXtype
+
+    // $ANTLR start synpred69_InternalOXtype
+    public final void synpred69_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2865:2: ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) )
+        // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+        {
+        // InternalOXtype.g:2865:2: ( ( rule__XSwitchExpression__Group_2_0__0 ) )
+        // InternalOXtype.g:2866:3: ( rule__XSwitchExpression__Group_2_0__0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXSwitchExpressionAccess().getGroup_2_0()); 
+        }
+        // InternalOXtype.g:2867:3: ( rule__XSwitchExpression__Group_2_0__0 )
+        // InternalOXtype.g:2867:4: rule__XSwitchExpression__Group_2_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XSwitchExpression__Group_2_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred69_InternalOXtype
+
+    // $ANTLR start synpred73_InternalOXtype
+    public final void synpred73_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2949:2: ( ( ( rule__XVariableDeclaration__Group_2_0__0 ) ) )
+        // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+        {
+        // InternalOXtype.g:2949:2: ( ( rule__XVariableDeclaration__Group_2_0__0 ) )
+        // InternalOXtype.g:2950:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXVariableDeclarationAccess().getGroup_2_0()); 
+        }
+        // InternalOXtype.g:2951:3: ( rule__XVariableDeclaration__Group_2_0__0 )
+        // InternalOXtype.g:2951:4: rule__XVariableDeclaration__Group_2_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XVariableDeclaration__Group_2_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred73_InternalOXtype
+
+    // $ANTLR start synpred74_InternalOXtype
+    public final void synpred74_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2970:2: ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) )
+        // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+        {
+        // InternalOXtype.g:2970:2: ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) )
+        // InternalOXtype.g:2971:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsAssignment_3_1_0()); 
+        }
+        // InternalOXtype.g:2972:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 )
+        // InternalOXtype.g:2972:4: rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred74_InternalOXtype
+
+    // $ANTLR start synpred80_InternalOXtype
+    public final void synpred80_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:3051:2: ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) )
+        // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+        {
+        // InternalOXtype.g:3051:2: ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) )
+        // InternalOXtype.g:3052:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+        {
+        if ( state.backtracking==0 ) {
+           before(grammarAccess.getXConstructorCallAccess().getArgumentsAssignment_4_1_0()); 
+        }
+        // InternalOXtype.g:3053:3: ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 )
+        // InternalOXtype.g:3053:4: rule__XConstructorCall__ArgumentsAssignment_4_1_0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XConstructorCall__ArgumentsAssignment_4_1_0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred80_InternalOXtype
+
+    // $ANTLR start synpred100_InternalOXtype
+    public final void synpred100_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:4853:3: ( rule__XAssignment__Group_1_1__0 )
+        // InternalOXtype.g:4853:3: rule__XAssignment__Group_1_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XAssignment__Group_1_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred100_InternalOXtype
+
+    // $ANTLR start synpred102_InternalOXtype
+    public final void synpred102_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5204:3: ( rule__XOrExpression__Group_1__0 )
+        // InternalOXtype.g:5204:3: rule__XOrExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XOrExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred102_InternalOXtype
+
+    // $ANTLR start synpred103_InternalOXtype
+    public final void synpred103_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5393:3: ( rule__XAndExpression__Group_1__0 )
+        // InternalOXtype.g:5393:3: rule__XAndExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XAndExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred103_InternalOXtype
+
+    // $ANTLR start synpred104_InternalOXtype
+    public final void synpred104_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5582:3: ( rule__XEqualityExpression__Group_1__0 )
+        // InternalOXtype.g:5582:3: rule__XEqualityExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XEqualityExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred104_InternalOXtype
+
+    // $ANTLR start synpred105_InternalOXtype
+    public final void synpred105_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5771:3: ( rule__XRelationalExpression__Alternatives_1 )
+        // InternalOXtype.g:5771:3: rule__XRelationalExpression__Alternatives_1
+        {
+        pushFollow(FOLLOW_2);
+        rule__XRelationalExpression__Alternatives_1();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred105_InternalOXtype
+
+    // $ANTLR start synpred106_InternalOXtype
+    public final void synpred106_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6149:3: ( rule__XOtherOperatorExpression__Group_1__0 )
+        // InternalOXtype.g:6149:3: rule__XOtherOperatorExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XOtherOperatorExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred106_InternalOXtype
+
+    // $ANTLR start synpred107_InternalOXtype
+    public final void synpred107_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6662:3: ( rule__XAdditiveExpression__Group_1__0 )
+        // InternalOXtype.g:6662:3: rule__XAdditiveExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XAdditiveExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred107_InternalOXtype
+
+    // $ANTLR start synpred108_InternalOXtype
+    public final void synpred108_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6851:3: ( rule__XMultiplicativeExpression__Group_1__0 )
+        // InternalOXtype.g:6851:3: rule__XMultiplicativeExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XMultiplicativeExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred108_InternalOXtype
+
+    // $ANTLR start synpred109_InternalOXtype
+    public final void synpred109_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:7121:3: ( rule__XCastedExpression__Group_1__0 )
+        // InternalOXtype.g:7121:3: rule__XCastedExpression__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XCastedExpression__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred109_InternalOXtype
+
+    // $ANTLR start synpred110_InternalOXtype
+    public final void synpred110_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:7310:3: ( rule__XPostfixOperation__Group_1__0 )
+        // InternalOXtype.g:7310:3: rule__XPostfixOperation__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XPostfixOperation__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred110_InternalOXtype
+
+    // $ANTLR start synpred111_InternalOXtype
+    public final void synpred111_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:7445:3: ( rule__XMemberFeatureCall__Alternatives_1 )
+        // InternalOXtype.g:7445:3: rule__XMemberFeatureCall__Alternatives_1
+        {
+        pushFollow(FOLLOW_2);
+        rule__XMemberFeatureCall__Alternatives_1();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred111_InternalOXtype
+
+    // $ANTLR start synpred113_InternalOXtype
+    public final void synpred113_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:7743:3: ( rule__XMemberFeatureCall__Group_1_1_3__0 )
+        // InternalOXtype.g:7743:3: rule__XMemberFeatureCall__Group_1_1_3__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XMemberFeatureCall__Group_1_1_3__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred113_InternalOXtype
+
+    // $ANTLR start synpred114_InternalOXtype
+    public final void synpred114_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:7769:3: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )
+        // InternalOXtype.g:7769:3: rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4
+        {
+        pushFollow(FOLLOW_2);
+        rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred114_InternalOXtype
+
+    // $ANTLR start synpred122_InternalOXtype
+    public final void synpred122_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:8742:3: ( rule__XClosure__Group_1__0 )
+        // InternalOXtype.g:8742:3: rule__XClosure__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XClosure__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred122_InternalOXtype
+
+    // $ANTLR start synpred129_InternalOXtype
+    public final void synpred129_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:9713:3: ( rule__XIfExpression__Group_6__0 )
+        // InternalOXtype.g:9713:3: rule__XIfExpression__Group_6__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XIfExpression__Group_6__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred129_InternalOXtype
+
+    // $ANTLR start synpred132_InternalOXtype
+    public final void synpred132_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:10173:3: ( rule__XSwitchExpression__Group_2_1_0__0 )
+        // InternalOXtype.g:10173:3: rule__XSwitchExpression__Group_2_1_0__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XSwitchExpression__Group_2_1_0__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred132_InternalOXtype
+
+    // $ANTLR start synpred145_InternalOXtype
+    public final void synpred145_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:12306:3: ( rule__XFeatureCall__Group_3__0 )
+        // InternalOXtype.g:12306:3: rule__XFeatureCall__Group_3__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XFeatureCall__Group_3__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred145_InternalOXtype
+
+    // $ANTLR start synpred146_InternalOXtype
+    public final void synpred146_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:12332:3: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )
+        // InternalOXtype.g:12332:3: rule__XFeatureCall__FeatureCallArgumentsAssignment_4
+        {
+        pushFollow(FOLLOW_2);
+        rule__XFeatureCall__FeatureCallArgumentsAssignment_4();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred146_InternalOXtype
+
+    // $ANTLR start synpred150_InternalOXtype
+    public final void synpred150_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:12792:3: ( rule__XConstructorCall__Group_3__0 )
+        // InternalOXtype.g:12792:3: rule__XConstructorCall__Group_3__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XConstructorCall__Group_3__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred150_InternalOXtype
+
+    // $ANTLR start synpred151_InternalOXtype
+    public final void synpred151_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:12819:3: ( rule__XConstructorCall__Group_4__0 )
+        // InternalOXtype.g:12819:3: rule__XConstructorCall__Group_4__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XConstructorCall__Group_4__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred151_InternalOXtype
+
+    // $ANTLR start synpred152_InternalOXtype
+    public final void synpred152_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:12845:3: ( rule__XConstructorCall__ArgumentsAssignment_5 )
+        // InternalOXtype.g:12845:3: rule__XConstructorCall__ArgumentsAssignment_5
+        {
+        pushFollow(FOLLOW_2);
+        rule__XConstructorCall__ArgumentsAssignment_5();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred152_InternalOXtype
+
+    // $ANTLR start synpred157_InternalOXtype
+    public final void synpred157_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:13736:3: ( rule__XReturnExpression__ExpressionAssignment_2 )
+        // InternalOXtype.g:13736:3: rule__XReturnExpression__ExpressionAssignment_2
+        {
+        pushFollow(FOLLOW_2);
+        rule__XReturnExpression__ExpressionAssignment_2();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred157_InternalOXtype
+
+    // $ANTLR start synpred158_InternalOXtype
+    public final void synpred158_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:13878:4: ( rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0 )
+        // InternalOXtype.g:13878:4: rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XTryCatchFinallyExpression__CatchClausesAssignment_3_0_0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred158_InternalOXtype
+
+    // $ANTLR start synpred159_InternalOXtype
+    public final void synpred159_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:13905:3: ( rule__XTryCatchFinallyExpression__Group_3_0_1__0 )
+        // InternalOXtype.g:13905:3: rule__XTryCatchFinallyExpression__Group_3_0_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__XTryCatchFinallyExpression__Group_3_0_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred159_InternalOXtype
+
+    // $ANTLR start synpred160_InternalOXtype
+    public final void synpred160_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:14418:3: ( rule__QualifiedName__Group_1__0 )
+        // InternalOXtype.g:14418:3: rule__QualifiedName__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__QualifiedName__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred160_InternalOXtype
+
+    // $ANTLR start synpred162_InternalOXtype
+    public final void synpred162_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:14634:3: ( rule__JvmTypeReference__Group_0_1__0 )
+        // InternalOXtype.g:14634:3: rule__JvmTypeReference__Group_0_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__JvmTypeReference__Group_0_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred162_InternalOXtype
+
+    // $ANTLR start synpred166_InternalOXtype
+    public final void synpred166_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:15093:3: ( rule__JvmParameterizedTypeReference__Group_1__0 )
+        // InternalOXtype.g:15093:3: rule__JvmParameterizedTypeReference__Group_1__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__JvmParameterizedTypeReference__Group_1__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred166_InternalOXtype
+
+    // $ANTLR start synpred168_InternalOXtype
+    public final void synpred168_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:15228:3: ( rule__JvmParameterizedTypeReference__Group_1_4__0 )
+        // InternalOXtype.g:15228:3: rule__JvmParameterizedTypeReference__Group_1_4__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__JvmParameterizedTypeReference__Group_1_4__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred168_InternalOXtype
+
+    // $ANTLR start synpred169_InternalOXtype
+    public final void synpred169_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:15363:3: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )
+        // InternalOXtype.g:15363:3: rule__JvmParameterizedTypeReference__Group_1_4_2__0
+        {
+        pushFollow(FOLLOW_2);
+        rule__JvmParameterizedTypeReference__Group_1_4_2__0();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred169_InternalOXtype
+
+    // Delegated rules
+
+    public final boolean synpred114_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred114_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred73_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred73_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred152_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred152_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred8_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred8_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred160_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred160_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred157_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred157_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred69_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred69_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred169_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred169_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred122_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred122_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred105_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred105_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred56_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred56_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred107_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred107_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred74_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred74_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred102_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred102_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred110_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred110_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred145_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred145_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred158_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred158_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred162_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred162_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred132_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred132_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred166_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred166_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred106_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred106_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred146_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred146_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred33_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred33_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred159_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred159_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred129_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred129_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred150_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred150_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred111_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred111_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred103_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred103_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred109_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred109_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred7_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred7_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred47_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred47_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred80_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred80_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred100_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred100_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred34_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred34_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred113_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred113_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred168_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred168_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred104_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred104_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred6_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred6_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred151_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred151_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred55_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred55_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred108_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred108_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+
+
+    protected DFA2 dfa2 = new DFA2(this);
+    protected DFA4 dfa4 = new DFA4(this);
+    protected DFA5 dfa5 = new DFA5(this);
+    protected DFA6 dfa6 = new DFA6(this);
+    protected DFA13 dfa13 = new DFA13(this);
+    protected DFA21 dfa21 = new DFA21(this);
+    protected DFA24 dfa24 = new DFA24(this);
+    protected DFA25 dfa25 = new DFA25(this);
+    protected DFA28 dfa28 = new DFA28(this);
+    protected DFA33 dfa33 = new DFA33(this);
+    protected DFA36 dfa36 = new DFA36(this);
+    protected DFA56 dfa56 = new DFA56(this);
+    protected DFA62 dfa62 = new DFA62(this);
+    protected DFA69 dfa69 = new DFA69(this);
+    protected DFA70 dfa70 = new DFA70(this);
+    protected DFA78 dfa78 = new DFA78(this);
+    protected DFA88 dfa88 = new DFA88(this);
+    protected DFA101 dfa101 = new DFA101(this);
+    protected DFA102 dfa102 = new DFA102(this);
+    protected DFA106 dfa106 = new DFA106(this);
+    protected DFA107 dfa107 = new DFA107(this);
+    protected DFA108 dfa108 = new DFA108(this);
+    protected DFA113 dfa113 = new DFA113(this);
+    protected DFA122 dfa122 = new DFA122(this);
+    protected DFA125 dfa125 = new DFA125(this);
+    static final String dfa_1s = "\10\uffff";
+    static final String dfa_2s = "\2\uffff\1\5\4\uffff\1\5";
+    static final String dfa_3s = "\1\4\1\uffff\1\53\1\uffff\1\4\2\uffff\1\53";
+    static final String dfa_4s = "\1\123\1\uffff\1\63\1\uffff\1\44\2\uffff\1\63";
+    static final String dfa_5s = "\1\uffff\1\1\1\uffff\1\4\1\uffff\1\2\1\3\1\uffff";
+    static final String dfa_6s = "\10\uffff}>";
+    static final String[] dfa_7s = {
+            "\1\2\51\uffff\1\1\44\uffff\1\3",
+            "",
+            "\1\4\7\uffff\1\5",
+            "",
+            "\1\7\37\uffff\1\6",
+            "",
+            "",
+            "\1\4\7\uffff\1\5"
+    };
+
+    static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
+    static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s);
+    static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
+    static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s);
+    static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
+    static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
+    static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
+
+    class DFA2 extends DFA {
+
+        public DFA2(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 2;
+            this.eot = dfa_1;
+            this.eof = dfa_2;
+            this.min = dfa_3;
+            this.max = dfa_4;
+            this.accept = dfa_5;
+            this.special = dfa_6;
+            this.transition = dfa_7;
+        }
+        public String getDescription() {
+            return "2068:1: rule__XImportDeclaration__Alternatives_2 : ( ( ( rule__XImportDeclaration__Group_2_0__0 ) ) | ( ( rule__XImportDeclaration__ImportedTypeAssignment_2_1 ) ) | ( ( rule__XImportDeclaration__ImportedNamespaceAssignment_2_2 ) ) | ( ( rule__XImportDeclaration__Group_2_3__0 ) ) );";
+        }
+    }
+    static final String dfa_8s = "\43\uffff";
+    static final String dfa_9s = "\1\4\1\0\41\uffff";
+    static final String dfa_10s = "\1\130\1\0\41\uffff";
+    static final String dfa_11s = "\2\uffff\1\2\37\uffff\1\1";
+    static final String dfa_12s = "\1\uffff\1\0\41\uffff}>";
+    static final String[] dfa_13s = {
+            "\1\1\4\2\22\uffff\1\2\6\uffff\2\2\4\uffff\1\2\4\uffff\6\2\1\uffff\2\2\3\uffff\2\2\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\3\uffff\11\2\1\uffff\1\2\10\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s);
+    static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
+    static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s);
+    static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
+    static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
+    static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
+
+    class DFA4 extends DFA {
+
+        public DFA4(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 4;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_9;
+            this.max = dfa_10;
+            this.accept = dfa_11;
+            this.special = dfa_12;
+            this.transition = dfa_13;
+        }
+        public String getDescription() {
+            return "2122:1: rule__XAnnotation__Alternatives_3_1 : ( ( ( rule__XAnnotation__Group_3_1_0__0 ) ) | ( ( rule__XAnnotation__ValueAssignment_3_1_1 ) ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA4_1 = input.LA(1);
+
+                         
+                        int index4_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred6_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index4_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 4, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_14s = {
+            "\5\2\22\uffff\1\2\6\uffff\2\2\4\uffff\1\2\4\uffff\6\2\1\uffff\2\2\3\uffff\1\1\1\2\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\3\uffff\11\2\1\uffff\1\2\10\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_14 = unpackEncodedStringArray(dfa_14s);
+
+    class DFA5 extends DFA {
+
+        public DFA5(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 5;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_9;
+            this.max = dfa_10;
+            this.accept = dfa_11;
+            this.special = dfa_12;
+            this.transition = dfa_14;
+        }
+        public String getDescription() {
+            return "2143:1: rule__XAnnotationElementValueOrCommaList__Alternatives : ( ( ( rule__XAnnotationElementValueOrCommaList__Group_0__0 ) ) | ( ( rule__XAnnotationElementValueOrCommaList__Group_1__0 ) ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA5_1 = input.LA(1);
+
+                         
+                        int index5_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index5_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 5, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA6 extends DFA {
+
+        public DFA6(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 6;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_9;
+            this.max = dfa_10;
+            this.accept = dfa_11;
+            this.special = dfa_12;
+            this.transition = dfa_14;
+        }
+        public String getDescription() {
+            return "2164:1: rule__XAnnotationElementValue__Alternatives : ( ( ( rule__XAnnotationElementValue__Group_0__0 ) ) | ( ruleXAnnotationOrExpression ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA6_1 = input.LA(1);
+
+                         
+                        int index6_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred8_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index6_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 6, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_15s = "\13\uffff";
+    static final String dfa_16s = "\1\32\2\uffff\1\32\7\uffff";
+    static final String dfa_17s = "\1\41\2\uffff\1\36\7\uffff";
+    static final String dfa_18s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\6\1\3";
+    static final String dfa_19s = "\13\uffff}>";
+    static final String[] dfa_20s = {
+            "\1\3\1\6\1\1\1\2\1\4\1\5\1\7\1\10",
+            "",
+            "",
+            "\1\11\3\uffff\1\12",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s);
+    static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s);
+    static final char[] dfa_17 = DFA.unpackEncodedStringToUnsignedChars(dfa_17s);
+    static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
+    static final short[] dfa_19 = DFA.unpackEncodedString(dfa_19s);
+    static final short[][] dfa_20 = unpackEncodedStringArray(dfa_20s);
+
+    class DFA13 extends DFA {
+
+        public DFA13(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 13;
+            this.eot = dfa_15;
+            this.eof = dfa_15;
+            this.min = dfa_16;
+            this.max = dfa_17;
+            this.accept = dfa_18;
+            this.special = dfa_19;
+            this.transition = dfa_20;
+        }
+        public String getDescription() {
+            return "2365:1: rule__OpOther__Alternatives : ( ( '->' ) | ( '..<' ) | ( ( rule__OpOther__Group_2__0 ) ) | ( '..' ) | ( '=>' ) | ( ( rule__OpOther__Group_5__0 ) ) | ( ( rule__OpOther__Group_6__0 ) ) | ( '<>' ) | ( '?:' ) );";
+        }
+    }
+    static final String dfa_21s = "\12\uffff";
+    static final String dfa_22s = "\4\uffff\5\3\1\uffff";
+    static final String dfa_23s = "\1\53\2\4\1\uffff\5\4\1\uffff";
+    static final String dfa_24s = "\1\125\2\61\1\uffff\5\130\1\uffff";
+    static final String dfa_25s = "\3\uffff\1\2\5\uffff\1\1";
+    static final String dfa_26s = "\12\uffff}>";
+    static final String[] dfa_27s = {
+            "\1\1\50\uffff\1\2\1\3",
+            "\1\4\26\uffff\1\3\21\uffff\1\5\1\6\1\7\1\10\1\3",
+            "\1\4\26\uffff\1\3\21\uffff\1\5\1\6\1\7\1\10\1\3",
+            "",
+            "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+            "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+            "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+            "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+            "\5\3\4\uffff\1\11\46\3\1\uffff\34\3\3\uffff\2\3\1\uffff\2\3",
+            ""
+    };
+
+    static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s);
+    static final short[] dfa_22 = DFA.unpackEncodedString(dfa_22s);
+    static final char[] dfa_23 = DFA.unpackEncodedStringToUnsignedChars(dfa_23s);
+    static final char[] dfa_24 = DFA.unpackEncodedStringToUnsignedChars(dfa_24s);
+    static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s);
+    static final short[] dfa_26 = DFA.unpackEncodedString(dfa_26s);
+    static final short[][] dfa_27 = unpackEncodedStringArray(dfa_27s);
+
+    class DFA21 extends DFA {
+
+        public DFA21(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 21;
+            this.eot = dfa_21;
+            this.eof = dfa_22;
+            this.min = dfa_23;
+            this.max = dfa_24;
+            this.accept = dfa_25;
+            this.special = dfa_26;
+            this.transition = dfa_27;
+        }
+        public String getDescription() {
+            return "2599:1: rule__XMemberFeatureCall__Alternatives_1 : ( ( ( rule__XMemberFeatureCall__Group_1_0__0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1__0 ) ) );";
+        }
+    }
+    static final String dfa_28s = "\1\4\2\0\40\uffff";
+    static final String dfa_29s = "\1\130\2\0\40\uffff";
+    static final String dfa_30s = "\3\uffff\1\1\1\uffff\1\2\35\uffff";
+    static final String dfa_31s = "\1\uffff\1\0\1\1\40\uffff}>";
+    static final String[] dfa_32s = {
+            "\1\1\4\5\22\uffff\1\5\3\uffff\1\3\2\uffff\2\5\4\uffff\1\5\4\uffff\6\5\2\uffff\1\2\3\uffff\2\5\2\uffff\1\5\1\uffff\1\5\1\uffff\1\5\3\uffff\11\5\1\uffff\1\5\6\uffff\1\3\1\uffff\1\5",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final char[] dfa_28 = DFA.unpackEncodedStringToUnsignedChars(dfa_28s);
+    static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s);
+    static final short[] dfa_30 = DFA.unpackEncodedString(dfa_30s);
+    static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s);
+    static final short[][] dfa_32 = unpackEncodedStringArray(dfa_32s);
+
+    class DFA24 extends DFA {
+
+        public DFA24(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 24;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_28;
+            this.max = dfa_29;
+            this.accept = dfa_30;
+            this.special = dfa_31;
+            this.transition = dfa_32;
+        }
+        public String getDescription() {
+            return "2668:1: rule__XMemberFeatureCall__Alternatives_1_1_3_1 : ( ( ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_3_1_0 ) ) | ( ( rule__XMemberFeatureCall__Group_1_1_3_1_1__0 ) ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA24_1 = input.LA(1);
+
+                         
+                        int index24_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred47_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index24_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA24_2 = input.LA(1);
+
+                         
+                        int index24_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred47_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index24_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 24, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_33s = "\40\uffff";
+    static final String dfa_34s = "\1\4\26\uffff\1\0\10\uffff";
+    static final String dfa_35s = "\1\130\26\uffff\1\0\10\uffff";
+    static final String dfa_36s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11";
+    static final String dfa_37s = "\27\uffff\1\0\10\uffff}>";
+    static final String[] dfa_38s = {
+            "\1\5\4\14\22\uffff\1\5\21\uffff\5\5\1\14\2\uffff\1\35\3\uffff\2\14\2\uffff\1\2\1\uffff\1\26\1\uffff\1\3\3\uffff\1\27\1\30\1\31\1\1\2\14\1\32\1\33\1\34\1\uffff\1\4\10\uffff\1\14",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_33 = DFA.unpackEncodedString(dfa_33s);
+    static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s);
+    static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s);
+    static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s);
+    static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s);
+    static final short[][] dfa_38 = unpackEncodedStringArray(dfa_38s);
+
+    class DFA25 extends DFA {
+
+        public DFA25(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 25;
+            this.eot = dfa_33;
+            this.eof = dfa_33;
+            this.min = dfa_34;
+            this.max = dfa_35;
+            this.accept = dfa_36;
+            this.special = dfa_37;
+            this.transition = dfa_38;
+        }
+        public String getDescription() {
+            return "2689:1: rule__XPrimaryExpression__Alternatives : ( ( ruleXConstructorCall ) | ( ruleXBlockExpression ) | ( ruleXSwitchExpression ) | ( ( ruleXSynchronizedExpression ) ) | ( ruleXFeatureCall ) | ( ruleXLiteral ) | ( ruleXIfExpression ) | ( ( ruleXForLoopExpression ) ) | ( ruleXBasicForLoopExpression ) | ( ruleXWhileExpression ) | ( ruleXDoWhileExpression ) | ( ruleXThrowExpression ) | ( ruleXReturnExpression ) | ( ruleXTryCatchFinallyExpression ) | ( ruleXParenthesizedExpression ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA25_23 = input.LA(1);
+
+                         
+                        int index25_23 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred55_InternalOXtype()) ) {s = 30;}
+
+                        else if ( (synpred56_InternalOXtype()) ) {s = 31;}
+
+                         
+                        input.seek(index25_23);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 25, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_39s = {
+            "\5\2\22\uffff\1\2\3\uffff\1\2\2\uffff\2\2\4\uffff\1\2\4\uffff\6\2\2\uffff\1\1\3\uffff\2\2\2\uffff\1\2\1\uffff\1\2\1\uffff\1\2\3\uffff\11\2\1\uffff\1\2\10\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_39 = unpackEncodedStringArray(dfa_39s);
+
+    class DFA28 extends DFA {
+
+        public DFA28(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 28;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_9;
+            this.max = dfa_10;
+            this.accept = dfa_11;
+            this.special = dfa_12;
+            this.transition = dfa_39;
+        }
+        public String getDescription() {
+            return "2860:1: rule__XSwitchExpression__Alternatives_2 : ( ( ( rule__XSwitchExpression__Group_2_0__0 ) ) | ( ( rule__XSwitchExpression__Group_2_1__0 ) ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA28_1 = input.LA(1);
+
+                         
+                        int index28_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred69_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index28_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 28, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA33 extends DFA {
+
+        public DFA33(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 33;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_28;
+            this.max = dfa_29;
+            this.accept = dfa_30;
+            this.special = dfa_31;
+            this.transition = dfa_32;
+        }
+        public String getDescription() {
+            return "2965:1: rule__XFeatureCall__Alternatives_3_1 : ( ( ( rule__XFeatureCall__FeatureCallArgumentsAssignment_3_1_0 ) ) | ( ( rule__XFeatureCall__Group_3_1_1__0 ) ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA33_1 = input.LA(1);
+
+                         
+                        int index33_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred74_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index33_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA33_2 = input.LA(1);
+
+                         
+                        int index33_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred74_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index33_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 33, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA36 extends DFA {
+
+        public DFA36(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 36;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_28;
+            this.max = dfa_29;
+            this.accept = dfa_30;
+            this.special = dfa_31;
+            this.transition = dfa_32;
+        }
+        public String getDescription() {
+            return "3046:1: rule__XConstructorCall__Alternatives_4_1 : ( ( ( rule__XConstructorCall__ArgumentsAssignment_4_1_0 ) ) | ( ( rule__XConstructorCall__Group_4_1_1__0 ) ) );";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA36_1 = input.LA(1);
+
+                         
+                        int index36_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred80_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index36_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA36_2 = input.LA(1);
+
+                         
+                        int index36_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred80_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index36_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 36, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_40s = "\1\10\11\uffff";
+    static final String dfa_41s = "\1\4\7\0\2\uffff";
+    static final String dfa_42s = "\1\130\7\0\2\uffff";
+    static final String dfa_43s = "\10\uffff\1\2\1\1";
+    static final String dfa_44s = "\1\uffff\1\1\1\3\1\6\1\0\1\2\1\4\1\5\2\uffff}>";
+    static final String[] dfa_45s = {
+            "\5\10\5\uffff\2\10\1\1\1\2\1\3\1\4\1\5\5\10\1\7\1\6\30\10\1\uffff\34\10\3\uffff\2\10\1\uffff\2\10",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            ""
+    };
+    static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s);
+    static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s);
+    static final char[] dfa_42 = DFA.unpackEncodedStringToUnsignedChars(dfa_42s);
+    static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s);
+    static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s);
+    static final short[][] dfa_45 = unpackEncodedStringArray(dfa_45s);
+
+    class DFA56 extends DFA {
+
+        public DFA56(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 56;
+            this.eot = dfa_21;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_45;
+        }
+        public String getDescription() {
+            return "4853:2: ( rule__XAssignment__Group_1_1__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA56_4 = input.LA(1);
+
+                         
+                        int index56_4 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_4);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA56_1 = input.LA(1);
+
+                         
+                        int index56_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA56_5 = input.LA(1);
+
+                         
+                        int index56_5 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_5);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 3 : 
+                        int LA56_2 = input.LA(1);
+
+                         
+                        int index56_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_2);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 4 : 
+                        int LA56_6 = input.LA(1);
+
+                         
+                        int index56_6 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_6);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 5 : 
+                        int LA56_7 = input.LA(1);
+
+                         
+                        int index56_7 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_7);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 6 : 
+                        int LA56_3 = input.LA(1);
+
+                         
+                        int index56_3 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred100_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index56_3);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 56, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_46s = "\1\1\12\uffff";
+    static final String dfa_47s = "\1\4\1\uffff\10\0\1\uffff";
+    static final String dfa_48s = "\1\130\1\uffff\10\0\1\uffff";
+    static final String dfa_49s = "\1\uffff\1\2\10\uffff\1\1";
+    static final String dfa_50s = "\2\uffff\1\2\1\5\1\7\1\3\1\1\1\6\1\0\1\4\1\uffff}>";
+    static final String[] dfa_51s = {
+            "\5\1\5\uffff\14\1\1\3\1\2\1\4\1\5\1\6\1\7\1\10\1\11\22\1\1\uffff\34\1\3\uffff\2\1\1\uffff\2\1",
+            "",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            ""
+    };
+    static final short[] dfa_46 = DFA.unpackEncodedString(dfa_46s);
+    static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s);
+    static final char[] dfa_48 = DFA.unpackEncodedStringToUnsignedChars(dfa_48s);
+    static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s);
+    static final short[] dfa_50 = DFA.unpackEncodedString(dfa_50s);
+    static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s);
+
+    class DFA62 extends DFA {
+
+        public DFA62(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 62;
+            this.eot = dfa_15;
+            this.eof = dfa_46;
+            this.min = dfa_47;
+            this.max = dfa_48;
+            this.accept = dfa_49;
+            this.special = dfa_50;
+            this.transition = dfa_51;
+        }
+        public String getDescription() {
+            return "()* loopback of 6149:2: ( rule__XOtherOperatorExpression__Group_1__0 )*";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA62_8 = input.LA(1);
+
+                         
+                        int index62_8 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_8);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA62_6 = input.LA(1);
+
+                         
+                        int index62_6 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_6);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA62_2 = input.LA(1);
+
+                         
+                        int index62_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_2);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 3 : 
+                        int LA62_5 = input.LA(1);
+
+                         
+                        int index62_5 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_5);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 4 : 
+                        int LA62_9 = input.LA(1);
+
+                         
+                        int index62_9 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_9);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 5 : 
+                        int LA62_3 = input.LA(1);
+
+                         
+                        int index62_3 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_3);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 6 : 
+                        int LA62_7 = input.LA(1);
+
+                         
+                        int index62_7 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_7);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 7 : 
+                        int LA62_4 = input.LA(1);
+
+                         
+                        int index62_4 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred106_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index62_4);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 62, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_52s = "\116\uffff";
+    static final String dfa_53s = "\1\2\115\uffff";
+    static final String dfa_54s = "\1\4\1\0\114\uffff";
+    static final String dfa_55s = "\1\130\1\0\114\uffff";
+    static final String dfa_56s = "\2\uffff\1\2\112\uffff\1\1";
+    static final String dfa_57s = "\1\uffff\1\0\114\uffff}>";
+    static final String[] dfa_58s = {
+            "\5\2\5\uffff\46\2\1\uffff\1\1\33\2\3\uffff\2\2\1\uffff\2\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s);
+    static final short[] dfa_53 = DFA.unpackEncodedString(dfa_53s);
+    static final char[] dfa_54 = DFA.unpackEncodedStringToUnsignedChars(dfa_54s);
+    static final char[] dfa_55 = DFA.unpackEncodedStringToUnsignedChars(dfa_55s);
+    static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s);
+    static final short[] dfa_57 = DFA.unpackEncodedString(dfa_57s);
+    static final short[][] dfa_58 = unpackEncodedStringArray(dfa_58s);
+
+    class DFA69 extends DFA {
+
+        public DFA69(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 69;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_58;
+        }
+        public String getDescription() {
+            return "7743:2: ( rule__XMemberFeatureCall__Group_1_1_3__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA69_1 = input.LA(1);
+
+                         
+                        int index69_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred113_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index69_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 69, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_59s = {
+            "\5\2\5\uffff\46\2\1\uffff\5\2\1\1\26\2\3\uffff\2\2\1\uffff\2\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_59 = unpackEncodedStringArray(dfa_59s);
+
+    class DFA70 extends DFA {
+
+        public DFA70(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 70;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_59;
+        }
+        public String getDescription() {
+            return "7769:2: ( rule__XMemberFeatureCall__MemberCallArgumentsAssignment_1_1_4 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA70_1 = input.LA(1);
+
+                         
+                        int index70_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred114_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index70_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 70, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_60s = "\46\uffff";
+    static final String dfa_61s = "\1\4\2\0\43\uffff";
+    static final String dfa_62s = "\1\130\2\0\43\uffff";
+    static final String dfa_63s = "\3\uffff\1\1\1\uffff\1\2\40\uffff";
+    static final String dfa_64s = "\1\uffff\1\0\1\1\43\uffff}>";
+    static final String[] dfa_65s = {
+            "\1\1\4\5\22\uffff\1\5\3\uffff\1\3\2\uffff\2\5\4\uffff\1\5\3\uffff\7\5\2\uffff\1\2\2\uffff\3\5\2\uffff\1\5\1\uffff\1\5\1\uffff\1\5\3\uffff\11\5\1\uffff\1\5\6\uffff\1\3\2\5",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_60 = DFA.unpackEncodedString(dfa_60s);
+    static final char[] dfa_61 = DFA.unpackEncodedStringToUnsignedChars(dfa_61s);
+    static final char[] dfa_62 = DFA.unpackEncodedStringToUnsignedChars(dfa_62s);
+    static final short[] dfa_63 = DFA.unpackEncodedString(dfa_63s);
+    static final short[] dfa_64 = DFA.unpackEncodedString(dfa_64s);
+    static final short[][] dfa_65 = unpackEncodedStringArray(dfa_65s);
+
+    class DFA78 extends DFA {
+
+        public DFA78(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 78;
+            this.eot = dfa_60;
+            this.eof = dfa_60;
+            this.min = dfa_61;
+            this.max = dfa_62;
+            this.accept = dfa_63;
+            this.special = dfa_64;
+            this.transition = dfa_65;
+        }
+        public String getDescription() {
+            return "8742:2: ( rule__XClosure__Group_1__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA78_1 = input.LA(1);
+
+                         
+                        int index78_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred122_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index78_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA78_2 = input.LA(1);
+
+                         
+                        int index78_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred122_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index78_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 78, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_66s = "\42\uffff";
+    static final String dfa_67s = "\1\4\2\0\37\uffff";
+    static final String dfa_68s = "\1\130\2\0\37\uffff";
+    static final String dfa_69s = "\3\uffff\1\1\1\2\35\uffff";
+    static final String dfa_70s = "\1\uffff\1\0\1\1\37\uffff}>";
+    static final String[] dfa_71s = {
+            "\1\1\4\4\22\uffff\1\4\3\uffff\1\3\2\uffff\2\4\4\uffff\1\4\4\uffff\6\4\2\uffff\1\2\3\uffff\2\4\2\uffff\1\4\1\uffff\1\4\1\uffff\1\4\3\uffff\11\4\1\uffff\1\4\10\uffff\1\4",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_66 = DFA.unpackEncodedString(dfa_66s);
+    static final char[] dfa_67 = DFA.unpackEncodedStringToUnsignedChars(dfa_67s);
+    static final char[] dfa_68 = DFA.unpackEncodedStringToUnsignedChars(dfa_68s);
+    static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s);
+    static final short[] dfa_70 = DFA.unpackEncodedString(dfa_70s);
+    static final short[][] dfa_71 = unpackEncodedStringArray(dfa_71s);
+
+    class DFA88 extends DFA {
+
+        public DFA88(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 88;
+            this.eot = dfa_66;
+            this.eof = dfa_66;
+            this.min = dfa_67;
+            this.max = dfa_68;
+            this.accept = dfa_69;
+            this.special = dfa_70;
+            this.transition = dfa_71;
+        }
+        public String getDescription() {
+            return "10173:2: ( rule__XSwitchExpression__Group_2_1_0__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA88_1 = input.LA(1);
+
+                         
+                        int index88_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred132_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 4;}
+
+                         
+                        input.seek(index88_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA88_2 = input.LA(1);
+
+                         
+                        int index88_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred132_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 4;}
+
+                         
+                        input.seek(index88_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 88, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA101 extends DFA {
+
+        public DFA101(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 101;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_58;
+        }
+        public String getDescription() {
+            return "12306:2: ( rule__XFeatureCall__Group_3__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA101_1 = input.LA(1);
+
+                         
+                        int index101_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred145_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index101_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 101, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA102 extends DFA {
+
+        public DFA102(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 102;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_59;
+        }
+        public String getDescription() {
+            return "12332:2: ( rule__XFeatureCall__FeatureCallArgumentsAssignment_4 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA102_1 = input.LA(1);
+
+                         
+                        int index102_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred146_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index102_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 102, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_72s = {
+            "\5\2\5\uffff\15\2\1\1\30\2\1\uffff\34\2\3\uffff\2\2\1\uffff\2\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_72 = unpackEncodedStringArray(dfa_72s);
+
+    class DFA106 extends DFA {
+
+        public DFA106(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 106;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_72;
+        }
+        public String getDescription() {
+            return "12792:2: ( rule__XConstructorCall__Group_3__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA106_1 = input.LA(1);
+
+                         
+                        int index106_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred150_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index106_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 106, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA107 extends DFA {
+
+        public DFA107(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 107;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_58;
+        }
+        public String getDescription() {
+            return "12819:2: ( rule__XConstructorCall__Group_4__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA107_1 = input.LA(1);
+
+                         
+                        int index107_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred151_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index107_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 107, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA108 extends DFA {
+
+        public DFA108(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 108;
+            this.eot = dfa_52;
+            this.eof = dfa_53;
+            this.min = dfa_54;
+            this.max = dfa_55;
+            this.accept = dfa_56;
+            this.special = dfa_57;
+            this.transition = dfa_59;
+        }
+        public String getDescription() {
+            return "12845:2: ( rule__XConstructorCall__ArgumentsAssignment_5 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA108_1 = input.LA(1);
+
+                         
+                        int index108_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred152_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index108_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 108, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_73s = "\1\41\115\uffff";
+    static final String dfa_74s = "\1\4\40\0\55\uffff";
+    static final String dfa_75s = "\1\130\40\0\55\uffff";
+    static final String dfa_76s = "\41\uffff\1\2\53\uffff\1\1";
+    static final String dfa_77s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>";
+    static final String[] dfa_78s = {
+            "\1\1\1\23\1\24\1\25\1\27\5\uffff\15\41\1\15\6\41\1\10\1\7\4\41\1\6\4\41\1\2\1\3\1\4\1\5\1\16\1\21\1\41\1\uffff\1\40\3\41\1\17\1\20\2\41\1\12\1\41\1\31\1\41\1\13\3\41\1\32\1\33\1\34\1\11\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41\3\uffff\2\41\1\uffff\1\41\1\22",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[] dfa_73 = DFA.unpackEncodedString(dfa_73s);
+    static final char[] dfa_74 = DFA.unpackEncodedStringToUnsignedChars(dfa_74s);
+    static final char[] dfa_75 = DFA.unpackEncodedStringToUnsignedChars(dfa_75s);
+    static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s);
+    static final short[] dfa_77 = DFA.unpackEncodedString(dfa_77s);
+    static final short[][] dfa_78 = unpackEncodedStringArray(dfa_78s);
+
+    class DFA113 extends DFA {
+
+        public DFA113(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 113;
+            this.eot = dfa_52;
+            this.eof = dfa_73;
+            this.min = dfa_74;
+            this.max = dfa_75;
+            this.accept = dfa_76;
+            this.special = dfa_77;
+            this.transition = dfa_78;
+        }
+        public String getDescription() {
+            return "13736:2: ( rule__XReturnExpression__ExpressionAssignment_2 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA113_1 = input.LA(1);
+
+                         
+                        int index113_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA113_2 = input.LA(1);
+
+                         
+                        int index113_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_2);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA113_3 = input.LA(1);
+
+                         
+                        int index113_3 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_3);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 3 : 
+                        int LA113_4 = input.LA(1);
+
+                         
+                        int index113_4 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_4);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 4 : 
+                        int LA113_5 = input.LA(1);
+
+                         
+                        int index113_5 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_5);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 5 : 
+                        int LA113_6 = input.LA(1);
+
+                         
+                        int index113_6 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_6);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 6 : 
+                        int LA113_7 = input.LA(1);
+
+                         
+                        int index113_7 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_7);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 7 : 
+                        int LA113_8 = input.LA(1);
+
+                         
+                        int index113_8 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_8);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 8 : 
+                        int LA113_9 = input.LA(1);
+
+                         
+                        int index113_9 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_9);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 9 : 
+                        int LA113_10 = input.LA(1);
+
+                         
+                        int index113_10 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_10);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 10 : 
+                        int LA113_11 = input.LA(1);
+
+                         
+                        int index113_11 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_11);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 11 : 
+                        int LA113_12 = input.LA(1);
+
+                         
+                        int index113_12 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_12);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 12 : 
+                        int LA113_13 = input.LA(1);
+
+                         
+                        int index113_13 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_13);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 13 : 
+                        int LA113_14 = input.LA(1);
+
+                         
+                        int index113_14 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_14);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 14 : 
+                        int LA113_15 = input.LA(1);
+
+                         
+                        int index113_15 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_15);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 15 : 
+                        int LA113_16 = input.LA(1);
+
+                         
+                        int index113_16 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_16);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 16 : 
+                        int LA113_17 = input.LA(1);
+
+                         
+                        int index113_17 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_17);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 17 : 
+                        int LA113_18 = input.LA(1);
+
+                         
+                        int index113_18 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_18);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 18 : 
+                        int LA113_19 = input.LA(1);
+
+                         
+                        int index113_19 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_19);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 19 : 
+                        int LA113_20 = input.LA(1);
+
+                         
+                        int index113_20 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_20);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 20 : 
+                        int LA113_21 = input.LA(1);
+
+                         
+                        int index113_21 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_21);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 21 : 
+                        int LA113_22 = input.LA(1);
+
+                         
+                        int index113_22 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_22);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 22 : 
+                        int LA113_23 = input.LA(1);
+
+                         
+                        int index113_23 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_23);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 23 : 
+                        int LA113_24 = input.LA(1);
+
+                         
+                        int index113_24 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_24);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 24 : 
+                        int LA113_25 = input.LA(1);
+
+                         
+                        int index113_25 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_25);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 25 : 
+                        int LA113_26 = input.LA(1);
+
+                         
+                        int index113_26 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_26);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 26 : 
+                        int LA113_27 = input.LA(1);
+
+                         
+                        int index113_27 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_27);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 27 : 
+                        int LA113_28 = input.LA(1);
+
+                         
+                        int index113_28 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_28);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 28 : 
+                        int LA113_29 = input.LA(1);
+
+                         
+                        int index113_29 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_29);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 29 : 
+                        int LA113_30 = input.LA(1);
+
+                         
+                        int index113_30 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_30);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 30 : 
+                        int LA113_31 = input.LA(1);
+
+                         
+                        int index113_31 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_31);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 31 : 
+                        int LA113_32 = input.LA(1);
+
+                         
+                        int index113_32 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred157_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index113_32);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 113, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_79s = "\117\uffff";
+    static final String dfa_80s = "\1\2\116\uffff";
+    static final String dfa_81s = "\1\4\1\0\115\uffff";
+    static final String dfa_82s = "\1\130\1\0\115\uffff";
+    static final String dfa_83s = "\2\uffff\1\2\113\uffff\1\1";
+    static final String dfa_84s = "\1\uffff\1\0\115\uffff}>";
+    static final String[] dfa_85s = {
+            "\5\2\5\uffff\15\2\1\1\30\2\1\uffff\34\2\1\uffff\1\2\1\uffff\2\2\1\uffff\2\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s);
+    static final short[] dfa_80 = DFA.unpackEncodedString(dfa_80s);
+    static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s);
+    static final char[] dfa_82 = DFA.unpackEncodedStringToUnsignedChars(dfa_82s);
+    static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s);
+    static final short[] dfa_84 = DFA.unpackEncodedString(dfa_84s);
+    static final short[][] dfa_85 = unpackEncodedStringArray(dfa_85s);
+
+    class DFA122 extends DFA {
+
+        public DFA122(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 122;
+            this.eot = dfa_79;
+            this.eof = dfa_80;
+            this.min = dfa_81;
+            this.max = dfa_82;
+            this.accept = dfa_83;
+            this.special = dfa_84;
+            this.transition = dfa_85;
+        }
+        public String getDescription() {
+            return "15093:2: ( rule__JvmParameterizedTypeReference__Group_1__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA122_1 = input.LA(1);
+
+                         
+                        int index122_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred166_InternalOXtype()) ) {s = 78;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index122_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 122, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA125 extends DFA {
+
+        public DFA125(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 125;
+            this.eot = dfa_79;
+            this.eof = dfa_80;
+            this.min = dfa_81;
+            this.max = dfa_82;
+            this.accept = dfa_83;
+            this.special = dfa_84;
+            this.transition = dfa_85;
+        }
+        public String getDescription() {
+            return "15363:2: ( rule__JvmParameterizedTypeReference__Group_1_4_2__0 )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA125_1 = input.LA(1);
+
+                         
+                        int index125_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred169_InternalOXtype()) ) {s = 78;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index125_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 125, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+ 
+
+    public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
+    public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000012L});
+    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000800000000000L});
+    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000400000000010L,0x0000000000080000L});
+    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0008000000000000L});
+    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0001000000000010L});
+    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000001000000010L});
+    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000000010L});
+    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0010000000000000L});
+    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0020000000000000L});
+    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0xA677E10C080001F0L,0x000000000100BFE2L});
+    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0080000000000000L});
+    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0080000000000002L});
+    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0xA637E10C080001F0L,0x000000000100BFE2L});
+    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000002000L});
+    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0xA737E10C080001F0L,0x000000000100BFE2L});
+    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0200000000000000L});
+    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0400000000000000L});
+    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0001E00000000010L});
+    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x000000000C1F0000L});
+    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000008000000L});
+    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000006000000L});
+    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000004000L});
+    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000000004002L});
+    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000008000L});
+    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000008002L});
+    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000001E00000L});
+    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000001E00002L});
+    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x080000000E000000L});
+    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x080000000E000002L});
+    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0020000080000010L});
+    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0800000000000000L});
+    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x00000003FC000000L});
+    public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x00000003FC000002L});
+    public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000040000000L});
+    public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000004000000L});
+    public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000088000000L});
+    public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000C00000000L});
+    public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000C00000002L});
+    public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x000000F000000000L});
+    public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x000000F000000002L});
+    public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000010C00000000L});
+    public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x1000000000000000L});
+    public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x1000000000000002L});
+    public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000060000000000L});
+    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000080000000000L,0x0000000000300000L});
+    public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000080000000002L,0x0000000000300000L});
+    public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000080000000000L,0x0000000000100000L});
+    public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0003E00008000010L});
+    public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0420000000000000L});
+    public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0020000080000010L,0x0000000000020000L});
+    public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0080000004000000L});
+    public static final BitSet FOLLOW_54 = new BitSet(new long[]{0xA677E10C880001F0L,0x000000000140BFE2L});
+    public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x2000000000000000L});
+    public static final BitSet FOLLOW_56 = new BitSet(new long[]{0xE637E10C080001F0L,0x000000000100BFE2L});
+    public static final BitSet FOLLOW_57 = new BitSet(new long[]{0xA637F10C880001F0L,0x0000000001C0BFE2L});
+    public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0100000000000000L});
+    public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0020000080000010L,0x0000000000400000L});
+    public static final BitSet FOLLOW_60 = new BitSet(new long[]{0xA637F10C080001F2L,0x000000000180BFE2L});
+    public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0040000000000000L});
+    public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x8000000000000000L});
+    public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
+    public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
+    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0xA637E10C880001F0L,0x000000000100BFE2L});
+    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x40A0000080000010L,0x000000000000001CL});
+    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x00A0000080000012L,0x0000000000000014L});
+    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
+    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x00A0000080000010L,0x0000000000000014L});
+    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000020L});
+    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0xA63FF10C080001F0L,0x000000000180BFE2L});
+    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0xA63FE10C080001F0L,0x000000000100BFE2L});
+    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0xA637F10C080001F0L,0x000000000180BFE2L});
+    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
+    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0xE637F10C080001F0L,0x000000000180BFE2L});
+    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000100000000000L,0x0000000000800000L});
+    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
+    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0420000008000000L});
+    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0004000000000000L,0x0000000001000000L});
+    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000200L});
+    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x00000000000000E0L});
+    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000100L});
+    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x06040000000001E0L,0x0000000001000600L});
+    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0440000000000000L});
+    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0400000000000002L});
+    public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
+    public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
+    public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
+    public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000000014000L});
+    public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
+    public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000000000002L,0x0000000000010000L});
+    public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
+    public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0000080000000000L});
+    public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0000080000000002L});
+    public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x00000000000000C0L});
+    public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0060000080000010L});
+    public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0002200000000000L});
+    public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
+    public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
+    public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000001000000000L});
+
+}
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeModule.xtend b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeModule.xtend
new file mode 100644
index 0000000..27096f7
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeModule.xtend
@@ -0,0 +1,11 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide
+
+
+/**
+ * Use this class to register ide components.
+ */
+class OXtypeIdeModule extends AbstractOXtypeIdeModule {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeSetup.xtend b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeSetup.xtend
new file mode 100644
index 0000000..d33817c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ide/src/org/eclipse/osbp/xtext/oxtype/ide/OXtypeIdeSetup.xtend
@@ -0,0 +1,20 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ide
+
+import com.google.inject.Guice
+import org.eclipse.osbp.xtext.oxtype.OXtypeRuntimeModule
+import org.eclipse.osbp.xtext.oxtype.OXtypeStandaloneSetup
+import org.eclipse.xtext.util.Modules2
+
+/**
+ * Initialization support for running Xtext languages as language servers.
+ */
+class OXtypeIdeSetup extends OXtypeStandaloneSetup {
+
+	override createInjector() {
+		Guice.createInjector(Modules2.mixin(new OXtypeRuntimeModule, new OXtypeIdeModule))
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/.project b/org.eclipse.osbp.xtext.oxtype.tests/.project
new file mode 100644
index 0000000..d1837d0
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype.tests</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<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.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..e37f93a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.tests
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.tests; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.osbp.xtext.oxtype,
+ org.junit;bundle-version="4.7.0",
+ org.eclipse.xtext.testing,
+ org.eclipse.xtext.xbase.junit,
+ org.eclipse.xtext.xbase.lib,
+ org.objectweb.asm;bundle-version="[5.0.1,6.0.0)";resolution:=optional
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.tests;x-internal=true
+Import-Package: org.hamcrest.core,
+ org.junit;version="4.5.0",
+ org.junit.runners.model;version="4.5.0",
+ org.junit.runner;version="4.5.0",
+ org.junit.runners;version="4.5.0",
+ org.junit.runner.manipulation;version="4.5.0",
+ org.junit.runner.notification;version="4.5.0"
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/build.properties b/org.eclipse.osbp.xtext.oxtype.tests/build.properties
new file mode 100644
index 0000000..5c6bbf9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/build.properties
@@ -0,0 +1,6 @@
+source.. = src/,\
+           src-gen/,\
+           xtend-gen/
+bin.includes = .,\
+               META-INF/
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/pom.xml b/org.eclipse.osbp.xtext.oxtype.tests/pom.xml
new file mode 100644
index 0000000..cc37357
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/pom.xml
@@ -0,0 +1,30 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+		<artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.xtext.oxtype.tests</artifactId>
+	<packaging>eclipse-test-plugin</packaging>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>tycho-surefire-plugin</artifactId>
+				<version>${tycho-version}</version>
+				<configuration>
+					<failIfNoTests>false</failIfNoTests>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/src-gen/org/eclipse/osbp/xtext/oxtype/tests/OXtypeInjectorProvider.java b/org.eclipse.osbp.xtext.oxtype.tests/src-gen/org/eclipse/osbp/xtext/oxtype/tests/OXtypeInjectorProvider.java
new file mode 100644
index 0000000..4a4ed2d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/src-gen/org/eclipse/osbp/xtext/oxtype/tests/OXtypeInjectorProvider.java
@@ -0,0 +1,66 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.tests;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.osbp.xtext.oxtype.OXtypeRuntimeModule;
+import org.eclipse.osbp.xtext.oxtype.OXtypeStandaloneSetup;
+import org.eclipse.xtext.testing.GlobalRegistries;
+import org.eclipse.xtext.testing.GlobalRegistries.GlobalStateMemento;
+import org.eclipse.xtext.testing.IInjectorProvider;
+import org.eclipse.xtext.testing.IRegistryConfigurator;
+
+public class OXtypeInjectorProvider implements IInjectorProvider, IRegistryConfigurator {
+
+	protected GlobalStateMemento stateBeforeInjectorCreation;
+	protected GlobalStateMemento stateAfterInjectorCreation;
+	protected Injector injector;
+
+	static {
+		GlobalRegistries.initializeDefaults();
+	}
+
+	@Override
+	public Injector getInjector() {
+		if (injector == null) {
+			stateBeforeInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+			this.injector = internalCreateInjector();
+			stateAfterInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+		}
+		return injector;
+	}
+
+	protected Injector internalCreateInjector() {
+		return new OXtypeStandaloneSetup() {
+			@Override
+			public Injector createInjector() {
+				return Guice.createInjector(createRuntimeModule());
+			}
+		}.createInjectorAndDoEMFRegistration();
+	}
+
+	protected OXtypeRuntimeModule createRuntimeModule() {
+		// make it work also with Maven/Tycho and OSGI
+		// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=493672
+		return new OXtypeRuntimeModule() {
+			@Override
+			public ClassLoader bindClassLoaderToInstance() {
+				return OXtypeInjectorProvider.class
+						.getClassLoader();
+			}
+		};
+	}
+
+	@Override
+	public void restoreRegistry() {
+		stateBeforeInjectorCreation.restoreGlobalState();
+	}
+
+	@Override
+	public void setupRegistry() {
+		getInjector();
+		stateAfterInjectorCreation.restoreGlobalState();
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.tests/src/org/eclipse/osbp/xtext/oxtype/tests/OXtypeParsingTest.xtend b/org.eclipse.osbp.xtext.oxtype.tests/src/org/eclipse/osbp/xtext/oxtype/tests/OXtypeParsingTest.xtend
new file mode 100644
index 0000000..aae0f44
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.tests/src/org/eclipse/osbp/xtext/oxtype/tests/OXtypeParsingTest.xtend
@@ -0,0 +1,29 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.tests
+
+import com.google.inject.Inject
+import org.eclipse.xtext.testing.InjectWith
+import org.eclipse.xtext.testing.XtextRunner
+import org.eclipse.xtext.testing.util.ParseHelper
+import org.junit.Assert
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+
+@RunWith(XtextRunner)
+@InjectWith(OXtypeInjectorProvider)
+class OXtypeParsingTest {
+	@Inject
+	ParseHelper<OXImportDeclaration> parseHelper
+	
+	@Test
+	def void loadModel() {
+		val result = parseHelper.parse('''
+			Hello Xtext!
+		''')
+		Assert.assertNotNull(result)
+		Assert.assertTrue(result.eResource.errors.isEmpty)
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/.project b/org.eclipse.osbp.xtext.oxtype.ui.tests/.project
new file mode 100644
index 0000000..584b481
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype.ui.tests</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<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.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.ui.tests/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..57062ae
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/META-INF/MANIFEST.MF
@@ -0,0 +1,22 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.ui.tests
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.ui.tests; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.osbp.xtext.oxtype.ui,
+ org.junit;bundle-version="4.7.0",
+ org.eclipse.xtext.testing,
+ org.eclipse.xtext.xbase.junit,
+ org.eclipse.core.runtime,
+ org.eclipse.ui.workbench;resolution:=optional
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.ui.tests;x-internal=true
+Import-Package: org.hamcrest.core,
+ org.junit;version="4.5.0",
+ org.junit.runners.model;version="4.5.0",
+ org.junit.runner;version="4.5.0",
+ org.junit.runners;version="4.5.0",
+ org.junit.runner.manipulation;version="4.5.0",
+ org.junit.runner.notification;version="4.5.0"
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/build.properties b/org.eclipse.osbp.xtext.oxtype.ui.tests/build.properties
new file mode 100644
index 0000000..5c6bbf9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/build.properties
@@ -0,0 +1,6 @@
+source.. = src/,\
+           src-gen/,\
+           xtend-gen/
+bin.includes = .,\
+               META-INF/
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/pom.xml b/org.eclipse.osbp.xtext.oxtype.ui.tests/pom.xml
new file mode 100644
index 0000000..62f29eb
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/pom.xml
@@ -0,0 +1,63 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+		<artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.xtext.oxtype.ui.tests</artifactId>
+	<packaging>eclipse-test-plugin</packaging>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>tycho-surefire-plugin</artifactId>
+				<version>${tycho-version}</version>
+				<configuration>
+					<failIfNoTests>false</failIfNoTests>
+					<useUIHarness>true</useUIHarness>
+				</configuration>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.tycho</groupId>
+				<artifactId>target-platform-configuration</artifactId>
+				<configuration>
+					<dependency-resolution>
+						<extraRequirements>
+							<!-- to get the org.eclipse.osgi.compatibility.state plugin
+							if the target platform is Luna or later.
+							(backward compatible with kepler and previous versions)
+							see https://bugs.eclipse.org/bugs/show_bug.cgi?id=492149 -->
+							<requirement>
+								<type>eclipse-feature</type>
+								<id>org.eclipse.rcp</id>
+								<versionRange>0.0.0</versionRange>
+							</requirement>
+						</extraRequirements>
+					</dependency-resolution>
+				</configuration>
+			</plugin>
+		</plugins>
+	</build>
+
+	<profiles>
+		<profile>
+			<id>testing-on-mac</id>
+			<activation>
+				<os>
+					<family>mac</family>
+				</os>
+			</activation>
+			<properties>
+				<tycho.testArgLine>-XstartOnFirstThread</tycho.testArgLine>
+			</properties>
+		</profile>
+	</profiles>
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/org/eclipse/osbp/xtext/oxtype/ui/tests/OXtypeUiInjectorProvider.java b/org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/org/eclipse/osbp/xtext/oxtype/ui/tests/OXtypeUiInjectorProvider.java
new file mode 100644
index 0000000..1604aa9
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/org/eclipse/osbp/xtext/oxtype/ui/tests/OXtypeUiInjectorProvider.java
@@ -0,0 +1,17 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.tests;
+
+import com.google.inject.Injector;
+import org.eclipse.osbp.xtext.oxtype.ui.internal.OxtypeActivator;
+import org.eclipse.xtext.testing.IInjectorProvider;
+
+public class OXtypeUiInjectorProvider implements IInjectorProvider {
+
+	@Override
+	public Injector getInjector() {
+		return OxtypeActivator.getInstance().getInjector("org.eclipse.osbp.xtext.oxtype.OXtype");
+	}
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/.project b/org.eclipse.osbp.xtext.oxtype.ui/.project
new file mode 100644
index 0000000..152539f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype.ui</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<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.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype.ui/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..15e4773
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/META-INF/MANIFEST.MF
@@ -0,0 +1,28 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype.ui
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype.ui; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.xtext.ui,
+ org.eclipse.xtext.ui.shared,
+ org.eclipse.xtext.ui.codetemplates.ui,
+ org.eclipse.ui.editors;bundle-version="3.5.0",
+ org.eclipse.ui.ide;bundle-version="3.5.0",
+ org.eclipse.xtext.xbase.lib,
+ org.eclipse.xtext.common.types.ui,
+ org.eclipse.xtend.lib;resolution:=optional,
+ org.eclipse.ui,
+ org.eclipse.xtext.xbase.ui,
+ org.eclipse.compare,
+ org.eclipse.xtext.builder,
+ org.eclipse.jdt.debug.ui,
+ org.eclipse.osbp.xtext.oxtype,
+ org.eclipse.osbp.xtext.oxtype.ide
+Import-Package: org.apache.log4j
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Export-Package: org.eclipse.osbp.xtext.oxtype.ui.internal,
+ org.eclipse.osbp.xtext.oxtype.ui.quickfix,
+ org.eclipse.osbp.xtext.oxtype.ui.contentassist
+Bundle-Activator: org.eclipse.osbp.xtext.oxtype.ui.internal.OxtypeActivator
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/build.properties b/org.eclipse.osbp.xtext.oxtype.ui/build.properties
new file mode 100644
index 0000000..323f56c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/build.properties
@@ -0,0 +1,7 @@
+source.. = src/,\
+           src-gen/,\
+           xtend-gen/
+bin.includes = .,\
+               META-INF/,\
+               plugin.xml
+bin.excludes = **/*.xtend
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml
new file mode 100644
index 0000000..00a296d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml
@@ -0,0 +1,569 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin>
+	<extension
+		point="org.eclipse.ui.editors">
+		<editor
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+			contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+			default="true"
+			extensions="oxtype"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype"
+			matchingStrategy="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher"
+			name="OXtype Editor">
+		</editor>
+	</extension>
+	<extension
+		point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+			commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+			commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate">
+		<activeWhen>
+			<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+			</reference>
+		</activeWhen>
+		</handler>
+		<!-- copy qualified name -->
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedNameHandler"
+			commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName">
+			<activeWhen>
+				<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+			</activeWhen>
+		</handler>
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedNameHandler"
+			commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName">
+			<activeWhen>
+				<and>
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+					<iterate>
+						<adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+					</iterate>
+				</and>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.core.expressions.definitions">
+		<definition id="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+			<and>
+				<reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+				<with variable="activeEditor">
+					<test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+						value="org.eclipse.osbp.xtext.oxtype.OXtype"
+						forcePluginActivation="true"/>
+				</with>
+			</and>
+		</definition>
+		<definition id="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened">
+			<and>
+				<reference definitionId="isXtextEditorActive"/>
+				<with variable="activeEditor">
+					<test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+						value="org.eclipse.osbp.xtext.oxtype.OXtype"
+						forcePluginActivation="true"/>
+				</with>
+			</and>
+		</definition>
+	</extension>
+	<extension
+			point="org.eclipse.ui.preferencePages">
+		<page
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype"
+			name="OXtype">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.coloring"
+			name="Syntax Coloring">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.templates"
+			name="Templates">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+	</extension>
+	<extension
+			point="org.eclipse.ui.propertyPages">
+		<page
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype"
+			name="OXtype">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+			<enabledWhen>
+				<adapt type="org.eclipse.core.resources.IProject"/>
+			</enabledWhen>
+			<filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+		</page>
+	</extension>
+	<extension
+		point="org.eclipse.ui.keywords">
+		<keyword
+			id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"
+			label="OXtype"/>
+	</extension>
+	<extension
+		point="org.eclipse.ui.commands">
+	<command
+			description="Trigger expensive validation"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+			name="Validate">
+	</command>
+	<!-- copy qualified name -->
+	<command
+			id="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+			categoryId="org.eclipse.ui.category.edit"
+			description="Copy the qualified name for the selected element"
+			name="Copy Qualified Name">
+	</command>
+	<command
+			id="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+			categoryId="org.eclipse.ui.category.edit"
+			description="Copy the qualified name for the selected element"
+			name="Copy Qualified Name">
+	</command>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.edit">
+			 <command
+				 commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+				 style="push"
+				 tooltip="Trigger expensive validation">
+			<visibleWhen checkEnabled="false">
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</visibleWhen>
+		</command>
+		</menuContribution>
+		<!-- copy qualified name -->
+		<menuContribution locationURI="popup:#TextEditorContext?after=copy">
+			<command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+				style="push" tooltip="Copy Qualified Name">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+				</visibleWhen>
+			</command>
+		</menuContribution>
+		<menuContribution locationURI="menu:edit?after=copy">
+			<command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+				style="push" tooltip="Copy Qualified Name">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+				</visibleWhen>
+			</command>
+		</menuContribution>
+		<menuContribution locationURI="popup:org.eclipse.xtext.ui.outline?after=additions">
+			<command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+				style="push" tooltip="Copy Qualified Name">
+				<visibleWhen checkEnabled="false">
+					<and>
+						<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+						<iterate>
+							<adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+						</iterate>
+					</and>
+				</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.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+			commandId="org.eclipse.xtext.ui.editor.FindReferences">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<!-- adding resource factories -->
+	<extension
+		point="org.eclipse.emf.ecore.extension_parser">
+		<parser
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+			type="oxtype">
+		</parser>
+	</extension>
+	<extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+		<resourceServiceProvider
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+			uriExtension="oxtype">
+		</resourceServiceProvider>
+	</extension>
+	<!-- marker definitions for org.eclipse.osbp.xtext.oxtype.OXtype -->
+	<extension
+			id="oxtype.check.fast"
+			name="OXtype Problem"
+			point="org.eclipse.core.resources.markers">
+		<super type="org.eclipse.xtext.ui.check.fast"/>
+		<persistent value="true"/>
+	</extension>
+	<extension
+			id="oxtype.check.normal"
+			name="OXtype Problem"
+			point="org.eclipse.core.resources.markers">
+		<super type="org.eclipse.xtext.ui.check.normal"/>
+		<persistent value="true"/>
+	</extension>
+	<extension
+			id="oxtype.check.expensive"
+			name="OXtype Problem"
+			point="org.eclipse.core.resources.markers">
+		<super type="org.eclipse.xtext.ui.check.expensive"/>
+		<persistent value="true"/>
+	</extension>
+	<extension point="org.eclipse.xtext.builder.participant">
+		<participant
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.IXtextBuilderParticipant"
+			fileExtensions="oxtype"/>
+	</extension>
+	<extension point="org.eclipse.ui.preferencePages">
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.preferencePage"
+			name="Compiler">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+	</extension>
+	<extension point="org.eclipse.ui.propertyPages">
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.propertyPage"
+			name="Compiler">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+			<enabledWhen>
+				<adapt type="org.eclipse.core.resources.IProject"/>
+			</enabledWhen>
+			<filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+		</page>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution locationURI="popup:#TextEditorContext?after=xtext.ui.openDeclaration">
+			<command
+				commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.OpenGeneratedCode"
+				style="push">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler"
+			commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand">
+			<activeWhen>
+				<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+			</activeWhen>
+		</handler>
+	</extension>
+	<!-- Quick Outline -->
+	<extension
+		point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+			commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.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.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<!-- quickfix marker resolution generator for org.eclipse.osbp.xtext.oxtype.OXtype -->
+	<extension
+			point="org.eclipse.ui.ide.markerResolution">
+		<markerResolutionGenerator
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+			markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.fast">
+			<attribute
+				name="FIXABLE_KEY"
+				value="true">
+			</attribute>
+		</markerResolutionGenerator>
+		<markerResolutionGenerator
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+			markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.normal">
+			<attribute
+				name="FIXABLE_KEY"
+				value="true">
+			</attribute>
+		</markerResolutionGenerator>
+		<markerResolutionGenerator
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+			markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.expensive">
+			<attribute
+				name="FIXABLE_KEY"
+				value="true">
+			</attribute>
+		</markerResolutionGenerator>
+	</extension>
+	<!-- Rename Refactoring -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.DefaultRenameElementHandler"
+			commandId="org.eclipse.xtext.ui.refactoring.RenameElement">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.edit">
+			<command commandId="org.eclipse.xtext.ui.refactoring.RenameElement"
+				style="push">
+				<visibleWhen checkEnabled="false">
+					<reference
+						definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.preferencePages">
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.refactoring"
+			name="Refactoring">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+	</extension>
+	<!-- Type Hierarchy  -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchyHandler"
+			commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.QuickTypeHierarchyHandler"
+			commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy"
+				style="push"
+				tooltip="Open Type Hierarchy">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy"
+				style="push"
+				tooltip="Quick Type Hierarchy">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<!-- Call Hierachy -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierachyHandler"
+			commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy"
+				style="push"
+				tooltip="Open Call Hierarchy">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.core.runtime.adapters">
+		<factory class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.smap.StratumBreakpointAdapterFactory"
+			adaptableType="org.eclipse.xtext.ui.editor.XtextEditor">
+			<adapter type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget"/>
+		</factory> 
+	</extension>
+	<extension point="org.eclipse.ui.editorActions">
+		<editorContribution targetID="org.eclipse.osbp.xtext.oxtype.OXtype" 
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerActions">
+			<action
+				label="Not Used"
+	 			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+				style="push"
+				actionID="RulerDoubleClick"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.doubleClickBreakpointAction"/>
+		</editorContribution>
+	</extension>
+	<extension point="org.eclipse.ui.popupMenus">
+		<viewerContribution
+			targetID="org.eclipse.osbp.xtext.oxtype.OXtype.RulerContext"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.RulerPopupActions">
+			<action
+				label="Toggle Breakpoint"
+				class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+				menubarPath="debug"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.toggleBreakpointAction">
+			</action>
+			<action
+				label="Not used"
+				class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerEnableDisableBreakpointActionDelegate"
+				menubarPath="debug"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.enableDisableBreakpointAction">
+			</action>
+			<action
+				label="Breakpoint Properties"
+				helpContextId="breakpoint_properties_action_context"
+				class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.jdt.debug.ui.actions.JavaBreakpointPropertiesRulerActionDelegate"
+				menubarPath="group.properties"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.openBreapointPropertiesAction">
+			</action>
+		</viewerContribution>
+	</extension>
+	<!-- Introduce Local Variable Refactoring -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.refactoring.ExtractVariableHandler"
+			commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.edit">
+			<command commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable"
+				style="push">
+				<visibleWhen checkEnabled="false">
+					<reference
+						definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<!-- Open implementation -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.navigation.OpenImplementationHandler"
+			commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="menu:navigate?after=open.ext4">
+			<command commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+				<visibleWhen checkEnabled="false">
+					<reference
+						definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.compare.contentViewers">
+		<viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentViewers"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+			extensions="oxtype">
+		</viewer>
+	</extension>
+	<extension point="org.eclipse.compare.contentMergeViewers">
+		<viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentMergeViewers"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+			extensions="oxtype" label="OXtype Compare">
+		</viewer>
+	</extension>
+	<extension point="org.eclipse.ui.editors.documentProviders">
+		<provider id="org.eclipse.osbp.xtext.oxtype.OXtype.editors.documentProviders"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.model.XtextDocumentProvider"
+			extensions="oxtype">
+		</provider>
+	</extension>
+	<extension point="org.eclipse.team.core.fileTypes">
+		<fileTypes
+			extension="oxtype"
+			type="text">
+		</fileTypes>
+	</extension>
+</plugin>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml_gen b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml_gen
new file mode 100644
index 0000000..00a296d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/plugin.xml_gen
@@ -0,0 +1,569 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin>
+	<extension
+		point="org.eclipse.ui.editors">
+		<editor
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.XtextEditor"
+			contributorClass="org.eclipse.ui.editors.text.TextEditorActionContributor"
+			default="true"
+			extensions="oxtype"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype"
+			matchingStrategy="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.editor.JavaEditorInputMatcher"
+			name="OXtype Editor">
+		</editor>
+	</extension>
+	<extension
+		point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclarationHandler"
+			commandId="org.eclipse.xtext.ui.editor.hyperlinking.OpenDeclaration">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.handler.ValidateActionHandler"
+			commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate">
+		<activeWhen>
+			<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+			</reference>
+		</activeWhen>
+		</handler>
+		<!-- copy qualified name -->
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedNameHandler"
+			commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName">
+			<activeWhen>
+				<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+			</activeWhen>
+		</handler>
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedNameHandler"
+			commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName">
+			<activeWhen>
+				<and>
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+					<iterate>
+						<adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+					</iterate>
+				</and>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.core.expressions.definitions">
+		<definition id="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+			<and>
+				<reference definitionId="isActiveEditorAnInstanceOfXtextEditor"/>
+				<with variable="activeEditor">
+					<test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+						value="org.eclipse.osbp.xtext.oxtype.OXtype"
+						forcePluginActivation="true"/>
+				</with>
+			</and>
+		</definition>
+		<definition id="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened">
+			<and>
+				<reference definitionId="isXtextEditorActive"/>
+				<with variable="activeEditor">
+					<test property="org.eclipse.xtext.ui.editor.XtextEditor.languageName"
+						value="org.eclipse.osbp.xtext.oxtype.OXtype"
+						forcePluginActivation="true"/>
+				</with>
+			</and>
+		</definition>
+	</extension>
+	<extension
+			point="org.eclipse.ui.preferencePages">
+		<page
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype"
+			name="OXtype">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.syntaxcoloring.SyntaxColoringPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.coloring"
+			name="Syntax Coloring">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.templates"
+			name="Templates">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+	</extension>
+	<extension
+			point="org.eclipse.ui.propertyPages">
+		<page
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.preferences.LanguageRootPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype"
+			name="OXtype">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+			<enabledWhen>
+				<adapt type="org.eclipse.core.resources.IProject"/>
+			</enabledWhen>
+			<filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+		</page>
+	</extension>
+	<extension
+		point="org.eclipse.ui.keywords">
+		<keyword
+			id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"
+			label="OXtype"/>
+	</extension>
+	<extension
+		point="org.eclipse.ui.commands">
+	<command
+			description="Trigger expensive validation"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+			name="Validate">
+	</command>
+	<!-- copy qualified name -->
+	<command
+			id="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+			categoryId="org.eclipse.ui.category.edit"
+			description="Copy the qualified name for the selected element"
+			name="Copy Qualified Name">
+	</command>
+	<command
+			id="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+			categoryId="org.eclipse.ui.category.edit"
+			description="Copy the qualified name for the selected element"
+			name="Copy Qualified Name">
+	</command>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.edit">
+			 <command
+				 commandId="org.eclipse.osbp.xtext.oxtype.OXtype.validate"
+				 style="push"
+				 tooltip="Trigger expensive validation">
+			<visibleWhen checkEnabled="false">
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</visibleWhen>
+		</command>
+		</menuContribution>
+		<!-- copy qualified name -->
+		<menuContribution locationURI="popup:#TextEditorContext?after=copy">
+			<command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+				style="push" tooltip="Copy Qualified Name">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+				</visibleWhen>
+			</command>
+		</menuContribution>
+		<menuContribution locationURI="menu:edit?after=copy">
+			<command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.EditorCopyQualifiedName"
+				style="push" tooltip="Copy Qualified Name">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+				</visibleWhen>
+			</command>
+		</menuContribution>
+		<menuContribution locationURI="popup:org.eclipse.xtext.ui.outline?after=additions">
+			<command commandId="org.eclipse.xtext.ui.editor.copyqualifiedname.OutlineCopyQualifiedName"
+				style="push" tooltip="Copy Qualified Name">
+				<visibleWhen checkEnabled="false">
+					<and>
+						<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.XtextEditor.opened" />
+						<iterate>
+							<adapt type="org.eclipse.xtext.ui.editor.outline.IOutlineNode" />
+						</iterate>
+					</and>
+				</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.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler"
+			commandId="org.eclipse.xtext.ui.editor.FindReferences">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<!-- adding resource factories -->
+	<extension
+		point="org.eclipse.emf.ecore.extension_parser">
+		<parser
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.resource.IResourceFactory"
+			type="oxtype">
+		</parser>
+	</extension>
+	<extension point="org.eclipse.xtext.extension_resourceServiceProvider">
+		<resourceServiceProvider
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.resource.IResourceUIServiceProvider"
+			uriExtension="oxtype">
+		</resourceServiceProvider>
+	</extension>
+	<!-- marker definitions for org.eclipse.osbp.xtext.oxtype.OXtype -->
+	<extension
+			id="oxtype.check.fast"
+			name="OXtype Problem"
+			point="org.eclipse.core.resources.markers">
+		<super type="org.eclipse.xtext.ui.check.fast"/>
+		<persistent value="true"/>
+	</extension>
+	<extension
+			id="oxtype.check.normal"
+			name="OXtype Problem"
+			point="org.eclipse.core.resources.markers">
+		<super type="org.eclipse.xtext.ui.check.normal"/>
+		<persistent value="true"/>
+	</extension>
+	<extension
+			id="oxtype.check.expensive"
+			name="OXtype Problem"
+			point="org.eclipse.core.resources.markers">
+		<super type="org.eclipse.xtext.ui.check.expensive"/>
+		<persistent value="true"/>
+	</extension>
+	<extension point="org.eclipse.xtext.builder.participant">
+		<participant
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.IXtextBuilderParticipant"
+			fileExtensions="oxtype"/>
+	</extension>
+	<extension point="org.eclipse.ui.preferencePages">
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.preferencePage"
+			name="Compiler">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+	</extension>
+	<extension point="org.eclipse.ui.propertyPages">
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.preferences.BuilderPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.compiler.propertyPage"
+			name="Compiler">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+			<enabledWhen>
+				<adapt type="org.eclipse.core.resources.IProject"/>
+			</enabledWhen>
+			<filter name="projectNature" value="org.eclipse.xtext.ui.shared.xtextNature"/>
+		</page>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution locationURI="popup:#TextEditorContext?after=xtext.ui.openDeclaration">
+			<command
+				commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.OpenGeneratedCode"
+				style="push">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler"
+			commandId="org.eclipse.xtext.ui.OpenGeneratedFileCommand">
+			<activeWhen>
+				<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened" />
+			</activeWhen>
+		</handler>
+	</extension>
+	<!-- Quick Outline -->
+	<extension
+		point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.outline.quickoutline.ShowQuickOutlineActionHandler"
+			commandId="org.eclipse.xtext.ui.editor.outline.QuickOutline">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.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.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<!-- quickfix marker resolution generator for org.eclipse.osbp.xtext.oxtype.OXtype -->
+	<extension
+			point="org.eclipse.ui.ide.markerResolution">
+		<markerResolutionGenerator
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+			markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.fast">
+			<attribute
+				name="FIXABLE_KEY"
+				value="true">
+			</attribute>
+		</markerResolutionGenerator>
+		<markerResolutionGenerator
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+			markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.normal">
+			<attribute
+				name="FIXABLE_KEY"
+				value="true">
+			</attribute>
+		</markerResolutionGenerator>
+		<markerResolutionGenerator
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.quickfix.MarkerResolutionGenerator"
+			markerType="org.eclipse.osbp.xtext.oxtype.ui.oxtype.check.expensive">
+			<attribute
+				name="FIXABLE_KEY"
+				value="true">
+			</attribute>
+		</markerResolutionGenerator>
+	</extension>
+	<!-- Rename Refactoring -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.DefaultRenameElementHandler"
+			commandId="org.eclipse.xtext.ui.refactoring.RenameElement">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.edit">
+			<command commandId="org.eclipse.xtext.ui.refactoring.RenameElement"
+				style="push">
+				<visibleWhen checkEnabled="false">
+					<reference
+						definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.ui.preferencePages">
+		<page
+			category="org.eclipse.osbp.xtext.oxtype.OXtype"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferencePage"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.refactoring"
+			name="Refactoring">
+			<keywordReference id="org.eclipse.osbp.xtext.oxtype.ui.keyword_OXtype"/>
+		</page>
+	</extension>
+	<!-- Type Hierarchy  -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchyHandler"
+			commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.QuickTypeHierarchyHandler"
+			commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenTypeHierarchy"
+				style="push"
+				tooltip="Open Type Hierarchy">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.jdt.ui.edit.text.java.open.hierarchy"
+				style="push"
+				tooltip="Quick Type Hierarchy">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<!-- Call Hierachy -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierachyHandler"
+			commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.open">
+			<command commandId="org.eclipse.xtext.xbase.ui.hierarchy.OpenCallHierarchy"
+				style="push"
+				tooltip="Open Call Hierarchy">
+				<visibleWhen checkEnabled="false">
+					<reference definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened"/>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.core.runtime.adapters">
+		<factory class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.builder.smap.StratumBreakpointAdapterFactory"
+			adaptableType="org.eclipse.xtext.ui.editor.XtextEditor">
+			<adapter type="org.eclipse.debug.ui.actions.IToggleBreakpointsTarget"/>
+		</factory> 
+	</extension>
+	<extension point="org.eclipse.ui.editorActions">
+		<editorContribution targetID="org.eclipse.osbp.xtext.oxtype.OXtype" 
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerActions">
+			<action
+				label="Not Used"
+	 			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+				style="push"
+				actionID="RulerDoubleClick"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.doubleClickBreakpointAction"/>
+		</editorContribution>
+	</extension>
+	<extension point="org.eclipse.ui.popupMenus">
+		<viewerContribution
+			targetID="org.eclipse.osbp.xtext.oxtype.OXtype.RulerContext"
+			id="org.eclipse.osbp.xtext.oxtype.OXtype.RulerPopupActions">
+			<action
+				label="Toggle Breakpoint"
+				class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerToggleBreakpointActionDelegate"
+				menubarPath="debug"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.toggleBreakpointAction">
+			</action>
+			<action
+				label="Not used"
+				class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.debug.ui.actions.RulerEnableDisableBreakpointActionDelegate"
+				menubarPath="debug"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.enableDisableBreakpointAction">
+			</action>
+			<action
+				label="Breakpoint Properties"
+				helpContextId="breakpoint_properties_action_context"
+				class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.jdt.debug.ui.actions.JavaBreakpointPropertiesRulerActionDelegate"
+				menubarPath="group.properties"
+				id="org.eclipse.osbp.xtext.oxtype.OXtype.rulerContextMenu.openBreapointPropertiesAction">
+			</action>
+		</viewerContribution>
+	</extension>
+	<!-- Introduce Local Variable Refactoring -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler 
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.refactoring.ExtractVariableHandler"
+			commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="popup:#TextEditorContext?after=group.edit">
+			<command commandId="org.eclipse.xtext.xbase.ui.refactoring.ExtractLocalVariable"
+				style="push">
+				<visibleWhen checkEnabled="false">
+					<reference
+						definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<!-- Open implementation -->
+	<extension point="org.eclipse.ui.handlers">
+		<handler
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.xbase.ui.navigation.OpenImplementationHandler"
+			commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+			<activeWhen>
+				<reference
+					definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+				</reference>
+			</activeWhen>
+		</handler>
+	</extension>
+	<extension point="org.eclipse.ui.menus">
+		<menuContribution
+			locationURI="menu:navigate?after=open.ext4">
+			<command commandId="org.eclipse.xtext.xbase.ui.OpenImplementationCommand">
+				<visibleWhen checkEnabled="false">
+					<reference
+						definitionId="org.eclipse.osbp.xtext.oxtype.OXtype.Editor.opened">
+					</reference>
+				</visibleWhen>
+			</command>
+		</menuContribution>
+	</extension>
+	<extension point="org.eclipse.compare.contentViewers">
+		<viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentViewers"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+			extensions="oxtype">
+		</viewer>
+	</extension>
+	<extension point="org.eclipse.compare.contentMergeViewers">
+		<viewer id="org.eclipse.osbp.xtext.oxtype.OXtype.compare.contentMergeViewers"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.compare.InjectableViewerCreator"
+			extensions="oxtype" label="OXtype Compare">
+		</viewer>
+	</extension>
+	<extension point="org.eclipse.ui.editors.documentProviders">
+		<provider id="org.eclipse.osbp.xtext.oxtype.OXtype.editors.documentProviders"
+			class="org.eclipse.osbp.xtext.oxtype.ui.OXtypeExecutableExtensionFactory:org.eclipse.xtext.ui.editor.model.XtextDocumentProvider"
+			extensions="oxtype">
+		</provider>
+	</extension>
+	<extension point="org.eclipse.team.core.fileTypes">
+		<fileTypes
+			extension="oxtype"
+			type="text">
+		</fileTypes>
+	</extension>
+</plugin>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/pom.xml b/org.eclipse.osbp.xtext.oxtype.ui/pom.xml
new file mode 100644
index 0000000..fb833d6
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/pom.xml
@@ -0,0 +1,22 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+		<artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.xtext.oxtype.ui</artifactId>
+	<packaging>eclipse-plugin</packaging>
+
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+			</plugin>
+		</plugins>
+	</build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/AbstractOXtypeUiModule.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/AbstractOXtypeUiModule.java
new file mode 100644
index 0000000..62b506a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/AbstractOXtypeUiModule.java
@@ -0,0 +1,381 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui;
+
+import com.google.inject.Binder;
+import com.google.inject.Provider;
+import com.google.inject.name.Names;
+import org.eclipse.compare.IViewerCreator;
+import org.eclipse.core.resources.IWorkspaceRoot;
+import org.eclipse.core.resources.ResourcesPlugin;
+import org.eclipse.jface.viewers.ILabelProvider;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.OXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.PartialOXtypeContentAssistParser;
+import org.eclipse.osbp.xtext.oxtype.ide.contentassist.antlr.internal.InternalOXtypeLexer;
+import org.eclipse.osbp.xtext.oxtype.ui.contentassist.OXtypeProposalProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.labeling.OXtypeDescriptionLabelProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.labeling.OXtypeLabelProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.outline.OXtypeOutlineTreeProvider;
+import org.eclipse.osbp.xtext.oxtype.ui.quickfix.OXtypeQuickfixProvider;
+import org.eclipse.ui.PlatformUI;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.eclipse.xtext.builder.BuilderParticipant;
+import org.eclipse.xtext.builder.EclipseOutputConfigurationProvider;
+import org.eclipse.xtext.builder.IXtextBuilderParticipant;
+import org.eclipse.xtext.builder.builderState.IBuilderState;
+import org.eclipse.xtext.builder.clustering.CurrentDescriptions;
+import org.eclipse.xtext.builder.impl.PersistentDataAwareDirtyResource;
+import org.eclipse.xtext.builder.nature.NatureAddingEditorCallback;
+import org.eclipse.xtext.builder.preferences.BuilderPreferenceAccess;
+import org.eclipse.xtext.common.types.ui.navigation.GlobalDerivedMemberAwareURIEditorOpener;
+import org.eclipse.xtext.common.types.ui.navigation.IDerivedMemberAwareEditorOpener;
+import org.eclipse.xtext.common.types.ui.query.IJavaSearchParticipation;
+import org.eclipse.xtext.common.types.ui.refactoring.JdtRenameSupport;
+import org.eclipse.xtext.common.types.ui.refactoring.participant.JdtRenameParticipant;
+import org.eclipse.xtext.common.types.ui.refactoring.participant.JvmMemberRenameStrategy;
+import org.eclipse.xtext.generator.IContextualOutputConfigurationProvider;
+import org.eclipse.xtext.ide.LexerIdeBindings;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.IContentAssistParser;
+import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.Lexer;
+import org.eclipse.xtext.ide.editor.partialEditing.IPartialEditingContentAssistParser;
+import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider;
+import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
+import org.eclipse.xtext.parser.antlr.LexerProvider;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.containers.IAllContainersState;
+import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
+import org.eclipse.xtext.service.SingletonBinding;
+import org.eclipse.xtext.ui.LanguageSpecific;
+import org.eclipse.xtext.ui.codetemplates.ui.AccessibleCodetemplatesActivator;
+import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.IPartialEditingContentAssistContextFactory;
+import org.eclipse.xtext.ui.codetemplates.ui.partialEditing.PartialEditingContentAssistContextFactory;
+import org.eclipse.xtext.ui.codetemplates.ui.preferences.AdvancedTemplatesPreferencePage;
+import org.eclipse.xtext.ui.codetemplates.ui.preferences.TemplatesLanguageConfiguration;
+import org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistrar;
+import org.eclipse.xtext.ui.codetemplates.ui.registry.LanguageRegistry;
+import org.eclipse.xtext.ui.compare.DefaultViewerCreator;
+import org.eclipse.xtext.ui.editor.DocumentBasedDirtyResource;
+import org.eclipse.xtext.ui.editor.GlobalURIEditorOpener;
+import org.eclipse.xtext.ui.editor.IURIEditorOpener;
+import org.eclipse.xtext.ui.editor.IXtextEditorCallback;
+import org.eclipse.xtext.ui.editor.XtextEditor;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+import org.eclipse.xtext.ui.editor.contentassist.FQNPrefixMatcher;
+import org.eclipse.xtext.ui.editor.contentassist.IContentProposalProvider;
+import org.eclipse.xtext.ui.editor.contentassist.IProposalConflictHelper;
+import org.eclipse.xtext.ui.editor.contentassist.PrefixMatcher;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.AntlrProposalConflictHelper;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.DelegatingContentAssistContextFactory;
+import org.eclipse.xtext.ui.editor.findrefs.FindReferencesHandler;
+import org.eclipse.xtext.ui.editor.findrefs.ReferenceQueryExecutor;
+import org.eclipse.xtext.ui.editor.model.XtextDocumentProvider;
+import org.eclipse.xtext.ui.editor.outline.IOutlineTreeProvider;
+import org.eclipse.xtext.ui.editor.outline.impl.IOutlineTreeStructureProvider;
+import org.eclipse.xtext.ui.editor.outline.impl.OutlineNodeElementOpener;
+import org.eclipse.xtext.ui.editor.preferences.IPreferenceStoreInitializer;
+import org.eclipse.xtext.ui.editor.quickfix.IssueResolutionProvider;
+import org.eclipse.xtext.ui.editor.templates.XtextTemplatePreferencePage;
+import org.eclipse.xtext.ui.generator.trace.OpenGeneratedFileHandler;
+import org.eclipse.xtext.ui.refactoring.IDependentElementsCalculator;
+import org.eclipse.xtext.ui.refactoring.IReferenceUpdater;
+import org.eclipse.xtext.ui.refactoring.IRenameRefactoringProvider;
+import org.eclipse.xtext.ui.refactoring.IRenameStrategy;
+import org.eclipse.xtext.ui.refactoring.impl.DefaultRenameStrategyProvider;
+import org.eclipse.xtext.ui.refactoring.ui.IRenameContextFactory;
+import org.eclipse.xtext.ui.refactoring.ui.IRenameSupport;
+import org.eclipse.xtext.ui.refactoring.ui.RefactoringPreferences;
+import org.eclipse.xtext.ui.resource.ResourceServiceDescriptionLabelProvider;
+import org.eclipse.xtext.ui.shared.Access;
+import org.eclipse.xtext.xbase.annotations.ui.DefaultXbaseWithAnnotationsUiModule;
+import org.eclipse.xtext.xbase.ui.editor.XbaseDocumentProvider;
+import org.eclipse.xtext.xbase.ui.editor.XbaseEditor;
+import org.eclipse.xtext.xbase.ui.generator.trace.XbaseOpenGeneratedFileHandler;
+import org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelFindReferenceHandler;
+import org.eclipse.xtext.xbase.ui.jvmmodel.findrefs.JvmModelReferenceQueryExecutor;
+import org.eclipse.xtext.xbase.ui.jvmmodel.navigation.DerivedMemberAwareEditorOpener;
+import org.eclipse.xtext.xbase.ui.jvmmodel.outline.JvmOutlineNodeElementOpener;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.DefaultJvmModelRenameStrategy;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelDependentElementsCalculator;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.JvmModelJdtRenameParticipantContext;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameContextFactory;
+import org.eclipse.xtext.xbase.ui.jvmmodel.refactoring.jdt.CombinedJvmJdtRenameRefactoringProvider;
+import org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixes;
+import org.eclipse.xtext.xbase.ui.quickfix.JavaTypeQuickfixesNoImportSection;
+import org.eclipse.xtext.xbase.ui.refactoring.XbaseReferenceUpdater;
+
+/**
+ * Manual modifications go to {@link OXtypeUiModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractOXtypeUiModule extends DefaultXbaseWithAnnotationsUiModule {
+
+	public AbstractOXtypeUiModule(AbstractUIPlugin plugin) {
+		super(plugin);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+	public Provider<? extends IAllContainersState> provideIAllContainersState() {
+		return Access.getJavaProjectsState();
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+	public Class<? extends XtextEditor> bindXtextEditor() {
+		return XbaseEditor.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+	public Class<? extends XtextDocumentProvider> bindXtextDocumentProvider() {
+		return XbaseDocumentProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ImplicitFragment
+	public Class<? extends OpenGeneratedFileHandler> bindOpenGeneratedFileHandler() {
+		return XbaseOpenGeneratedFileHandler.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends IProposalConflictHelper> bindIProposalConflictHelper() {
+		return AntlrProposalConflictHelper.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public void configureContentAssistLexer(Binder binder) {
+		binder.bind(Lexer.class)
+			.annotatedWith(Names.named(LexerIdeBindings.CONTENT_ASSIST))
+			.to(InternalOXtypeLexer.class);
+	}
+
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public void configureHighlightingLexer(Binder binder) {
+		binder.bind(org.eclipse.xtext.parser.antlr.Lexer.class)
+			.annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING))
+			.to(org.eclipse.osbp.xtext.oxtype.parser.antlr.internal.InternalOXtypeLexer.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public void configureHighlightingTokenDefProvider(Binder binder) {
+		binder.bind(ITokenDefProvider.class)
+			.annotatedWith(Names.named(LexerIdeBindings.HIGHLIGHTING))
+			.to(AntlrTokenDefProvider.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends ContentAssistContext.Factory> bindContentAssistContext$Factory() {
+		return DelegatingContentAssistContextFactory.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends IContentAssistParser> bindIContentAssistParser() {
+		return OXtypeParser.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public void configureContentAssistLexerProvider(Binder binder) {
+		binder.bind(InternalOXtypeLexer.class).toProvider(LexerProvider.create(InternalOXtypeLexer.class));
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public void configureIResourceDescriptionsBuilderScope(Binder binder) {
+		binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.NAMED_BUILDER_SCOPE)).to(CurrentDescriptions.ResourceSetAware.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public Class<? extends IXtextEditorCallback> bindIXtextEditorCallback() {
+		return NatureAddingEditorCallback.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public Class<? extends IContextualOutputConfigurationProvider> bindIContextualOutputConfigurationProvider() {
+		return EclipseOutputConfigurationProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public void configureIResourceDescriptionsPersisted(Binder binder) {
+		binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(IBuilderState.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public Class<? extends DocumentBasedDirtyResource> bindDocumentBasedDirtyResource() {
+		return PersistentDataAwareDirtyResource.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+	public Class<? extends IXtextBuilderParticipant> bindIXtextBuilderParticipant() {
+		return BuilderParticipant.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+	public IWorkspaceRoot bindIWorkspaceRootToInstance() {
+		return ResourcesPlugin.getWorkspace().getRoot();
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.generator.GeneratorFragment2
+	public void configureBuilderPreferenceStoreInitializer(Binder binder) {
+		binder.bind(IPreferenceStoreInitializer.class)
+			.annotatedWith(Names.named("builderPreferenceInitializer"))
+			.to(BuilderPreferenceAccess.Initializer.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2
+	public Class<? extends ILabelProvider> bindILabelProvider() {
+		return OXtypeLabelProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.labeling.LabelProviderFragment2
+	public void configureResourceUIServiceLabelProvider(Binder binder) {
+		binder.bind(ILabelProvider.class).annotatedWith(ResourceServiceDescriptionLabelProvider.class).to(OXtypeDescriptionLabelProvider.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2
+	public Class<? extends IOutlineTreeProvider> bindIOutlineTreeProvider() {
+		return OXtypeOutlineTreeProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.outline.OutlineTreeProviderFragment2
+	public Class<? extends IOutlineTreeStructureProvider> bindIOutlineTreeStructureProvider() {
+		return OXtypeOutlineTreeProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.quickfix.QuickfixProviderFragment2
+	public Class<? extends IssueResolutionProvider> bindIssueResolutionProvider() {
+		return OXtypeQuickfixProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.contentAssist.ContentAssistFragment2
+	public Class<? extends IContentProposalProvider> bindIContentProposalProvider() {
+		return OXtypeProposalProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+	public void configureIPreferenceStoreInitializer(Binder binder) {
+		binder.bind(IPreferenceStoreInitializer.class)
+			.annotatedWith(Names.named("RefactoringPreferences"))
+			.to(RefactoringPreferences.Initializer.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+	public Class<? extends IRenameSupport.Factory> bindIRenameSupport$Factory() {
+		return JdtRenameSupport.Factory.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+	public Class<? extends IRenameStrategy.Provider> bindIRenameStrategy$Provider() {
+		return JvmMemberRenameStrategy.Provider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.refactoring.RefactorElementNameFragment2
+	public void configureJvmMemberRenameStrategy$Provider$Delegate(Binder binder) {
+		binder.bind(IRenameStrategy.Provider.class).annotatedWith(JvmMemberRenameStrategy.Provider.Delegate.class).to(DefaultRenameStrategyProvider.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.types.TypesGeneratorFragment2
+	public Class<? extends PrefixMatcher> bindPrefixMatcher() {
+		return FQNPrefixMatcher.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends FindReferencesHandler> bindFindReferencesHandler() {
+		return JvmModelFindReferenceHandler.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends ReferenceQueryExecutor> bindReferenceQueryExecutor() {
+		return JvmModelReferenceQueryExecutor.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IDependentElementsCalculator> bindIDependentElementsCalculator() {
+		return JvmModelDependentElementsCalculator.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IRenameRefactoringProvider> bindIRenameRefactoringProvider() {
+		return CombinedJvmJdtRenameRefactoringProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IReferenceUpdater> bindIReferenceUpdater() {
+		return XbaseReferenceUpdater.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IRenameContextFactory> bindIRenameContextFactory() {
+		return CombinedJvmJdtRenameContextFactory.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IRenameStrategy> bindIRenameStrategy() {
+		return DefaultJvmModelRenameStrategy.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends JdtRenameParticipant.ContextFactory> bindJdtRenameParticipant$ContextFactory() {
+		return JvmModelJdtRenameParticipantContext.ContextFactory.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends OutlineNodeElementOpener> bindOutlineNodeElementOpener() {
+		return JvmOutlineNodeElementOpener.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends GlobalURIEditorOpener> bindGlobalURIEditorOpener() {
+		return GlobalDerivedMemberAwareURIEditorOpener.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IJavaSearchParticipation> bindIJavaSearchParticipation() {
+		return IJavaSearchParticipation.No.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public void configureLanguageSpecificURIEditorOpener(Binder binder) {
+		if (PlatformUI.isWorkbenchRunning()) {
+			binder.bind(IURIEditorOpener.class).annotatedWith(LanguageSpecific.class).to(DerivedMemberAwareEditorOpener.class);
+			binder.bind(IDerivedMemberAwareEditorOpener.class).to(DerivedMemberAwareEditorOpener.class);
+		}
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends JavaTypeQuickfixes> bindJavaTypeQuickfixes() {
+		return JavaTypeQuickfixesNoImportSection.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+	public Provider<? extends TemplatesLanguageConfiguration> provideTemplatesLanguageConfiguration() {
+		return AccessibleCodetemplatesActivator.getTemplatesLanguageConfigurationProvider();
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+	public Provider<? extends LanguageRegistry> provideLanguageRegistry() {
+		return AccessibleCodetemplatesActivator.getLanguageRegistry();
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+	@SingletonBinding(eager=true)
+	public Class<? extends LanguageRegistrar> bindLanguageRegistrar() {
+		return LanguageRegistrar.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+	public Class<? extends XtextTemplatePreferencePage> bindXtextTemplatePreferencePage() {
+		return AdvancedTemplatesPreferencePage.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+	public Class<? extends IPartialEditingContentAssistParser> bindIPartialEditingContentAssistParser() {
+		return PartialOXtypeContentAssistParser.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.templates.CodetemplatesGeneratorFragment2
+	public Class<? extends IPartialEditingContentAssistContextFactory> bindIPartialEditingContentAssistContextFactory() {
+		return PartialEditingContentAssistContextFactory.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.ui.compare.CompareFragment2
+	public Class<? extends IViewerCreator> bindIViewerCreator() {
+		return DefaultViewerCreator.class;
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/OXtypeExecutableExtensionFactory.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/OXtypeExecutableExtensionFactory.java
new file mode 100644
index 0000000..aa92e60
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/OXtypeExecutableExtensionFactory.java
@@ -0,0 +1,27 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui;
+
+import com.google.inject.Injector;
+import org.eclipse.osbp.xtext.oxtype.ui.internal.OxtypeActivator;
+import org.eclipse.xtext.ui.guice.AbstractGuiceAwareExecutableExtensionFactory;
+import org.osgi.framework.Bundle;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass. 
+ */
+public class OXtypeExecutableExtensionFactory extends AbstractGuiceAwareExecutableExtensionFactory {
+
+	@Override
+	protected Bundle getBundle() {
+		return OxtypeActivator.getInstance().getBundle();
+	}
+	
+	@Override
+	protected Injector getInjector() {
+		return OxtypeActivator.getInstance().getInjector(OxtypeActivator.ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE);
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/contentassist/AbstractOXtypeProposalProvider.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/contentassist/AbstractOXtypeProposalProvider.java
new file mode 100644
index 0000000..7bad6f1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/contentassist/AbstractOXtypeProposalProvider.java
@@ -0,0 +1,27 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.contentassist;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.ui.editor.contentassist.ContentAssistContext;
+import org.eclipse.xtext.ui.editor.contentassist.ICompletionProposalAcceptor;
+import org.eclipse.xtext.xbase.annotations.ui.contentassist.XbaseWithAnnotationsProposalProvider;
+
+/**
+ * Represents a generated, default implementation of superclass {@link XbaseWithAnnotationsProposalProvider}.
+ * Methods are dynamically dispatched on the first parameter, i.e., you can override them 
+ * with a more concrete subtype. 
+ */
+public abstract class AbstractOXtypeProposalProvider extends XbaseWithAnnotationsProposalProvider {
+
+	public void completeXImportDeclaration_FqnImport(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		// subclasses may override
+	}
+	public void completeXImportDeclaration_ImportedFullyQualifiedName(EObject model, Assignment assignment, ContentAssistContext context, ICompletionProposalAcceptor acceptor) {
+		completeRuleCall(((RuleCall)assignment.getTerminal()), context, acceptor);
+	}
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/internal/OxtypeActivator.java b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/internal/OxtypeActivator.java
new file mode 100644
index 0000000..426ca17
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src-gen/org/eclipse/osbp/xtext/oxtype/ui/internal/OxtypeActivator.java
@@ -0,0 +1,93 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.internal;
+
+import com.google.common.collect.Maps;
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import com.google.inject.Module;
+import java.util.Collections;
+import java.util.Map;
+import org.apache.log4j.Logger;
+import org.eclipse.osbp.xtext.oxtype.OXtypeRuntimeModule;
+import org.eclipse.osbp.xtext.oxtype.ui.OXtypeUiModule;
+import org.eclipse.ui.plugin.AbstractUIPlugin;
+import org.eclipse.xtext.ui.shared.SharedStateModule;
+import org.eclipse.xtext.util.Modules2;
+import org.osgi.framework.BundleContext;
+
+/**
+ * This class was generated. Customizations should only happen in a newly
+ * introduced subclass. 
+ */
+public class OxtypeActivator extends AbstractUIPlugin {
+
+	public static final String ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE = "org.eclipse.osbp.xtext.oxtype.OXtype";
+	
+	private static final Logger logger = Logger.getLogger(OxtypeActivator.class);
+	
+	private static OxtypeActivator INSTANCE;
+	
+	private Map<String, Injector> injectors = Collections.synchronizedMap(Maps.<String, Injector> newHashMapWithExpectedSize(1));
+	
+	@Override
+	public void start(BundleContext context) throws Exception {
+		super.start(context);
+		INSTANCE = this;
+	}
+	
+	@Override
+	public void stop(BundleContext context) throws Exception {
+		injectors.clear();
+		INSTANCE = null;
+		super.stop(context);
+	}
+	
+	public static OxtypeActivator getInstance() {
+		return INSTANCE;
+	}
+	
+	public Injector getInjector(String language) {
+		synchronized (injectors) {
+			Injector injector = injectors.get(language);
+			if (injector == null) {
+				injectors.put(language, injector = createInjector(language));
+			}
+			return injector;
+		}
+	}
+	
+	protected Injector createInjector(String language) {
+		try {
+			Module runtimeModule = getRuntimeModule(language);
+			Module sharedStateModule = getSharedStateModule();
+			Module uiModule = getUiModule(language);
+			Module mergedModule = Modules2.mixin(runtimeModule, sharedStateModule, uiModule);
+			return Guice.createInjector(mergedModule);
+		} catch (Exception e) {
+			logger.error("Failed to create injector for " + language);
+			logger.error(e.getMessage(), e);
+			throw new RuntimeException("Failed to create injector for " + language, e);
+		}
+	}
+	
+	protected Module getRuntimeModule(String grammar) {
+		if (ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE.equals(grammar)) {
+			return new OXtypeRuntimeModule();
+		}
+		throw new IllegalArgumentException(grammar);
+	}
+	
+	protected Module getUiModule(String grammar) {
+		if (ORG_ECLIPSE_OSBP_XTEXT_OXTYPE_OXTYPE.equals(grammar)) {
+			return new OXtypeUiModule(this);
+		}
+		throw new IllegalArgumentException(grammar);
+	}
+	
+	protected Module getSharedStateModule() {
+		return new SharedStateModule();
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/OXtypeUiModule.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/OXtypeUiModule.xtend
new file mode 100644
index 0000000..f9d994a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/OXtypeUiModule.xtend
@@ -0,0 +1,16 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui
+
+import org.eclipse.xtend.lib.annotations.FinalFieldsConstructor
+import org.eclipse.ui.plugin.AbstractUIPlugin
+
+/**
+ * Use this class to register components to be used within the Eclipse IDE.
+ */
+@FinalFieldsConstructor
+class OXtypeUiModule extends AbstractOXtypeUiModule {
+	
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/contentassist/OXtypeProposalProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/contentassist/OXtypeProposalProvider.xtend
new file mode 100644
index 0000000..58260a2
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/contentassist/OXtypeProposalProvider.xtend
@@ -0,0 +1,12 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.contentassist
+
+
+/**
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#content-assist
+ * on how to customize the content assistant.
+ */
+class OXtypeProposalProvider extends AbstractOXtypeProposalProvider {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeDescriptionLabelProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeDescriptionLabelProvider.xtend
new file mode 100644
index 0000000..f05419b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeDescriptionLabelProvider.xtend
@@ -0,0 +1,24 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.labeling
+
+import org.eclipse.xtext.xbase.ui.labeling.XbaseDescriptionLabelProvider
+
+/**
+ * Provides labels for IEObjectDescriptions and IResourceDescriptions.
+ * 
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#label-provider
+ */
+class OXtypeDescriptionLabelProvider extends XbaseDescriptionLabelProvider {
+
+	// Labels and icons can be computed like this:
+	
+//	override text(IEObjectDescription ele) {
+//		ele.name.toString
+//	}
+//	 
+//	override image(IEObjectDescription ele) {
+//		ele.EClass.name + '.gif'
+//	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeLabelProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeLabelProvider.xtend
new file mode 100644
index 0000000..28831f7
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/labeling/OXtypeLabelProvider.xtend
@@ -0,0 +1,31 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.labeling
+
+import com.google.inject.Inject
+import org.eclipse.emf.edit.ui.provider.AdapterFactoryLabelProvider
+import org.eclipse.xtext.xbase.ui.labeling.XbaseLabelProvider
+
+/**
+ * Provides labels for EObjects.
+ * 
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#label-provider
+ */
+class OXtypeLabelProvider extends XbaseLabelProvider {
+
+	@Inject
+	new(AdapterFactoryLabelProvider delegate) {
+		super(delegate);
+	}
+
+	// Labels and icons can be computed like this:
+	
+//	def text(Greeting ele) {
+//		'A greeting to ' + ele.name
+//	}
+//
+//	def image(Greeting ele) {
+//		'Greeting.gif'
+//	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/outline/OXtypeOutlineTreeProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/outline/OXtypeOutlineTreeProvider.xtend
new file mode 100644
index 0000000..ef5d958
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/outline/OXtypeOutlineTreeProvider.xtend
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.outline
+
+import org.eclipse.xtext.ui.editor.outline.impl.DefaultOutlineTreeProvider
+
+/**
+ * Customization of the default outline structure.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/304_ide_concepts.html#outline
+ */
+class OXtypeOutlineTreeProvider extends DefaultOutlineTreeProvider {
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/quickfix/OXtypeQuickfixProvider.xtend b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/quickfix/OXtypeQuickfixProvider.xtend
new file mode 100644
index 0000000..316c32e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype.ui/src/org/eclipse/osbp/xtext/oxtype/ui/quickfix/OXtypeQuickfixProvider.xtend
@@ -0,0 +1,24 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.ui.quickfix
+
+import org.eclipse.xtext.xbase.annotations.ui.quickfix.XbaseWithAnnotationsQuickfixProvider
+
+/**
+ * Custom quickfixes.
+ *
+ * See https://www.eclipse.org/Xtext/documentation/310_eclipse_support.html#quick-fixes
+ */
+class OXtypeQuickfixProvider extends XbaseWithAnnotationsQuickfixProvider {
+
+//	@Fix(OXtypeValidator.INVALID_NAME)
+//	def capitalizeName(Issue issue, IssueResolutionAcceptor acceptor) {
+//		acceptor.accept(issue, 'Capitalize name', 'Capitalize the name.', 'upcase.png') [
+//			context |
+//			val xtextDocument = context.xtextDocument
+//			val firstLetter = xtextDocument.get(issue.offset, 1)
+//			xtextDocument.replace(issue.offset, 1, firstLetter.toUpperCase)
+//		]
+//	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/.launch/Generate OXtype (oxtype) Language Infrastructure.launch b/org.eclipse.osbp.xtext.oxtype/.launch/Generate OXtype (oxtype) Language Infrastructure.launch
new file mode 100644
index 0000000..2c0ced0
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/.launch/Generate OXtype (oxtype) Language Infrastructure.launch
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<launchConfiguration type="org.eclipse.emf.mwe2.launch.Mwe2LaunchConfigurationType">
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_PATHS">
+<listEntry value="/org.eclipse.osbp.xtext.oxtype"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.core.MAPPED_RESOURCE_TYPES">
+<listEntry value="4"/>
+</listAttribute>
+<listAttribute key="org.eclipse.debug.ui.favoriteGroups">
+<listEntry value="org.eclipse.debug.ui.launchGroup.debug"/>
+<listEntry value="org.eclipse.debug.ui.launchGroup.run"/>
+</listAttribute>
+<stringAttribute key="org.eclipse.debug.core.ATTR_REFRESH_SCOPE" value="${working_set:&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;&#10;&lt;resources&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.parent&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.ide&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.ui&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.target&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.tests&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.ui.tests&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.tests&quot; type=&quot;4&quot;/&gt;&#10;&lt;item path=&quot;/org.eclipse.osbp.xtext.oxtype.ui.tests&quot; type=&quot;4&quot;/&gt;&#10;;&lt;/resources&gt;}"/>
+<stringAttribute key="org.eclipse.jdt.launching.MAIN_TYPE" value="org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROGRAM_ARGUMENTS" value="org.eclipse.osbp.xtext.oxtype.GenerateOXtype"/>
+<stringAttribute key="org.eclipse.jdt.launching.PROJECT_ATTR" value="org.eclipse.osbp.xtext.oxtype"/>
+<stringAttribute key="org.eclipse.jdt.launching.VM_ARGUMENTS" value="-Xmx512m"/>
+</launchConfiguration>
diff --git a/org.eclipse.osbp.xtext.oxtype/.project b/org.eclipse.osbp.xtext.oxtype/.project
new file mode 100644
index 0000000..0eb3ef4
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/.project
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>org.eclipse.osbp.xtext.oxtype</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.m2e.core.maven2Builder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<buildCommand>
+			<name>org.eclipse.xtext.ui.shared.xtextBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+		<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.m2e.core.maven2Nature</nature>
+		<nature>org.eclipse.xtext.ui.shared.xtextNature</nature>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+		<nature>org.eclipse.pde.PluginNature</nature>
+	</natures>
+</projectDescription>
diff --git a/org.eclipse.osbp.xtext.oxtype/META-INF/MANIFEST.MF b/org.eclipse.osbp.xtext.oxtype/META-INF/MANIFEST.MF
new file mode 100644
index 0000000..ca03f2e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/META-INF/MANIFEST.MF
@@ -0,0 +1,32 @@
+Manifest-Version: 1.0
+Bundle-ManifestVersion: 2
+Bundle-Name: org.eclipse.osbp.xtext.oxtype
+Bundle-Vendor: Eclipse OSBP
+Bundle-Version: 0.9.0.qualifier
+Bundle-SymbolicName: org.eclipse.osbp.xtext.oxtype; singleton:=true
+Bundle-ActivationPolicy: lazy
+Require-Bundle: org.eclipse.xtext,
+ org.eclipse.xtext.xbase,
+ org.eclipse.equinox.common;bundle-version="3.5.0",
+ org.eclipse.emf.ecore,
+ org.eclipse.xtext.common.types,
+ org.eclipse.xtext.xbase.lib,
+ org.antlr.runtime,
+ org.objectweb.asm;bundle-version="[5.0.1,6.0.0)";resolution:=optional,
+ org.eclipse.xtext.util,
+ org.eclipse.xtend.lib,
+ org.eclipse.emf.common
+Bundle-RequiredExecutionEnvironment: JavaSE-1.8
+Import-Package: org.apache.log4j,
+ org.slf4j;version="1.7.2"
+Export-Package: org.eclipse.osbp.xtext.oxtype;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.jvmmodel;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.oxtype,
+ org.eclipse.osbp.xtext.oxtype.oxtype.impl;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.oxtype.util,
+ org.eclipse.osbp.xtext.oxtype.parser.antlr;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.parser.antlr.internal;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.scoping,
+ org.eclipse.osbp.xtext.oxtype.serializer;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.services;x-internal:=true,
+ org.eclipse.osbp.xtext.oxtype.validation;x-internal:=true
diff --git a/org.eclipse.osbp.xtext.oxtype/build.properties b/org.eclipse.osbp.xtext.oxtype/build.properties
new file mode 100644
index 0000000..18d540b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/build.properties
@@ -0,0 +1,20 @@
+source.. = src/,\
+           src-gen/,\
+           xtend-gen/
+bin.includes = model/generated/,\
+               .,\
+               META-INF/,\
+               plugin.xml
+bin.excludes = **/*.mwe2,\
+               **/*.xtend
+additional.bundles = org.eclipse.xtext.xbase,\
+                     org.eclipse.xtext.common.types,\
+                     org.eclipse.xtext.xtext.generator,\
+                     org.eclipse.emf.codegen.ecore,\
+                     org.eclipse.emf.mwe.utils,\
+                     org.eclipse.emf.mwe2.launch,\
+                     org.eclipse.emf.mwe2.lib,\
+                     org.objectweb.asm,\
+                     org.apache.commons.logging,\
+                     org.apache.log4j,\
+                     com.ibm.icu
diff --git a/org.eclipse.osbp.xtext.oxtype/model/OXtype.ecore b/org.eclipse.osbp.xtext.oxtype/model/OXtype.ecore
new file mode 100644
index 0000000..63a4cd1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/model/OXtype.ecore
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<ecore:EPackage xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore" name="oxtype" nsURI="http://www.eclipse.org/osbp/xtext/oxtype/OXtype"
+    nsPrefix="oxtype">
+  <eClassifiers xsi:type="ecore:EClass" name="OXImportDeclaration" eSuperTypes="../../org.eclipse.xtext.xbase/model/Xtype.ecore#//XImportDeclaration">
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="fqnImport" eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EBoolean"/>
+    <eStructuralFeatures xsi:type="ecore:EAttribute" name="importedFullyQualifiedName"
+        eType="ecore:EDataType http://www.eclipse.org/emf/2002/Ecore#//EString"/>
+  </eClassifiers>
+</ecore:EPackage>
diff --git a/org.eclipse.osbp.xtext.oxtype/model/OXtype.genmodel b/org.eclipse.osbp.xtext.oxtype/model/OXtype.genmodel
new file mode 100644
index 0000000..9e5a89c
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/model/OXtype.genmodel
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<genmodel:GenModel xmi:version="2.0" xmlns:xmi="http://www.omg.org/XMI" xmlns:ecore="http://www.eclipse.org/emf/2002/Ecore"
+    xmlns:genmodel="http://www.eclipse.org/emf/2002/GenModel" copyrightText="generated by Xtext 2.11.0.beta2" modelDirectory="/org.eclipse.osbp.xtext.oxtype/src"
+    modelPluginID="org.eclipse.osbp.xtext.oxtype" forceOverwrite="true" modelName="OXtype"
+    updateClasspath="false" rootExtendsClass="org.eclipse.emf.ecore.impl.MinimalEObjectImpl$Container"
+    complianceLevel="6.0" copyrightFields="false" runtimeVersion="2.13" usedGenPackages="../../org.eclipse.xtext.xbase/model/Xbase.genmodel#//xtype ../../org.eclipse.xtext.common.types/model/JavaVMTypes.genmodel#//types">
+  <genPackages prefix="OXtype" basePackage="org.eclipse.osbp.xtext.oxtype" disposableProviderFactory="true"
+      fileExtensions="oxtype" ecorePackage="OXtype.ecore#/">
+    <genClasses ecoreClass="OXtype.ecore#//OXImportDeclaration">
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute OXtype.ecore#//OXImportDeclaration/fqnImport"/>
+      <genFeatures createChild="false" ecoreFeature="ecore:EAttribute OXtype.ecore#//OXImportDeclaration/importedFullyQualifiedName"/>
+    </genClasses>
+  </genPackages>
+</genmodel:GenModel>
diff --git a/org.eclipse.osbp.xtext.oxtype/plugin.properties b/org.eclipse.osbp.xtext.oxtype/plugin.properties
new file mode 100644
index 0000000..c5851f4
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/plugin.properties
@@ -0,0 +1,4 @@
+# generated by Xtext 2.11.0.beta2
+
+pluginName = OXtype Model
+providerName = www.example.org
diff --git a/org.eclipse.osbp.xtext.oxtype/plugin.xml b/org.eclipse.osbp.xtext.oxtype/plugin.xml
new file mode 100644
index 0000000..77bf11f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/plugin.xml
@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<?eclipse version="3.0"?>
+<plugin>
+   <extension point="org.eclipse.emf.ecore.generated_package">
+      <!-- @generated OXtype -->
+      <package
+            uri="http://www.eclipse.org/osbp/xtext/oxtype/OXtype"
+            class="org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage"
+            genModel="model/OXtype.genmodel"/>
+   </extension>
+</plugin>
diff --git a/org.eclipse.osbp.xtext.oxtype/pom.xml b/org.eclipse.osbp.xtext.oxtype/pom.xml
new file mode 100644
index 0000000..ac1f1f0
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/pom.xml
@@ -0,0 +1,140 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+		<artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+		<version>0.9.0-SNAPSHOT</version>
+		<relativePath>..</relativePath>
+	</parent>
+	<artifactId>org.eclipse.osbp.xtext.oxtype</artifactId>
+	<packaging>eclipse-plugin</packaging>
+ 
+	<build>
+		<plugins>
+			<plugin>
+				<groupId>org.codehaus.mojo</groupId>
+				<artifactId>exec-maven-plugin</artifactId>
+				<version>1.4.0</version>
+				<executions>
+					<execution>
+						<id>mwe2Launcher</id>
+						<phase>generate-sources</phase>
+						<goals>
+							<goal>java</goal>
+						</goals>
+					</execution>
+				</executions>
+				<configuration>
+					<mainClass>org.eclipse.emf.mwe2.launch.runtime.Mwe2Launcher</mainClass>
+					<arguments>
+						<argument>/${project.basedir}/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2</argument>
+						<argument>-p</argument>
+						<argument>rootPath=/${project.basedir}/..</argument>
+					</arguments>
+					<classpathScope>compile</classpathScope>
+					<includePluginDependencies>true</includePluginDependencies>
+					<cleanupDaemonThreads>false</cleanupDaemonThreads><!-- see https://bugs.eclipse.org/bugs/show_bug.cgi?id=475098#c3 -->
+				</configuration>
+				<dependencies>
+					<dependency>
+						<groupId>org.eclipse.emf</groupId>
+						<artifactId>org.eclipse.emf.mwe2.launch</artifactId>
+						<version>2.8.3</version>
+					</dependency>
+					<dependency>
+						<groupId>org.eclipse.xtext</groupId>
+						<artifactId>org.eclipse.xtext.xtext.generator</artifactId>
+						<version>${xtextVersion}</version>
+					</dependency>
+					<dependency>
+						<groupId>org.eclipse.xtext</groupId>
+						<artifactId>org.eclipse.xtext.xbase</artifactId>
+						<version>${xtextVersion}</version>
+					</dependency>
+				</dependencies>
+			</plugin>
+			<plugin>
+				<groupId>org.eclipse.xtend</groupId>
+				<artifactId>xtend-maven-plugin</artifactId>
+			</plugin>
+	
+			<plugin>
+				<groupId>org.apache.maven.plugins</groupId>
+				<artifactId>maven-clean-plugin</artifactId>
+				<configuration>
+					<filesets combine.children="append">
+						<fileset>
+							<directory>${basedir}/../org.eclipse.osbp.xtext.oxtype/src-gen/</directory>
+							<includes>
+								<include>**/*</include>
+							</includes>
+						</fileset>
+						<fileset>
+							<directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.tests/src-gen/</directory>
+							<includes>
+								<include>**/*</include>
+							</includes>
+						</fileset>
+						<fileset>
+							<directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.ide/src-gen/</directory>
+							<includes>
+								<include>**/*</include>
+							</includes>
+						</fileset>
+						<fileset>
+							<directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.ui/src-gen/</directory>
+							<includes>
+								<include>**/*</include>
+							</includes>
+						</fileset>
+						<fileset>
+							<directory>${basedir}/../org.eclipse.osbp.xtext.oxtype.ui.tests/src-gen/</directory>
+							<includes>
+								<include>**/*</include>
+							</includes>
+						</fileset>
+						<fileset>
+							<directory>${basedir}/model/generated/</directory>
+						</fileset>
+					</filesets>
+				</configuration>
+			</plugin>
+		</plugins>
+		<pluginManagement>
+			<plugins>
+				<plugin>
+					<groupId>org.eclipse.m2e</groupId>
+					<artifactId>lifecycle-mapping</artifactId>
+					<version>1.0.0</version>
+					<configuration>
+						<lifecycleMappingMetadata>
+							<pluginExecutions>
+								<pluginExecution>
+									<pluginExecutionFilter>
+										<groupId>
+											org.codehaus.mojo
+										</groupId>
+										<artifactId>
+											exec-maven-plugin
+										</artifactId>
+										<versionRange>
+											[1.2.1,)
+										</versionRange>
+										<goals>
+											<goal>java</goal>
+										</goals>
+									</pluginExecutionFilter>
+									<action>
+										<ignore></ignore>
+									</action>
+								</pluginExecution>
+							</pluginExecutions>
+						</lifecycleMappingMetadata>
+					</configuration>
+				</plugin>
+			</plugins>
+		</pluginManagement>
+	</build>
+
+</project>
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/AbstractOXtypeRuntimeModule.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/AbstractOXtypeRuntimeModule.java
new file mode 100644
index 0000000..89bb950
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/AbstractOXtypeRuntimeModule.java
@@ -0,0 +1,230 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype;
+
+import com.google.inject.Binder;
+import com.google.inject.Provider;
+import com.google.inject.name.Names;
+import java.util.Properties;
+import org.eclipse.osbp.xtext.oxtype.jvmmodel.OXtypeJvmModelInferrer;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.OXtypeAntlrTokenFileProvider;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.OXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.internal.InternalOXtypeLexer;
+import org.eclipse.osbp.xtext.oxtype.scoping.OXtypeScopeProvider;
+import org.eclipse.osbp.xtext.oxtype.serializer.OXtypeSemanticSequencer;
+import org.eclipse.osbp.xtext.oxtype.serializer.OXtypeSyntacticSequencer;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.osbp.xtext.oxtype.validation.OXtypeValidator;
+import org.eclipse.xtext.Constants;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.common.types.xtext.TypesAwareDefaultGlobalScopeProvider;
+import org.eclipse.xtext.naming.IQualifiedNameProvider;
+import org.eclipse.xtext.parser.IParser;
+import org.eclipse.xtext.parser.ITokenToStringConverter;
+import org.eclipse.xtext.parser.antlr.AntlrTokenDefProvider;
+import org.eclipse.xtext.parser.antlr.AntlrTokenToStringConverter;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+import org.eclipse.xtext.parser.antlr.ITokenDefProvider;
+import org.eclipse.xtext.parser.antlr.Lexer;
+import org.eclipse.xtext.parser.antlr.LexerBindings;
+import org.eclipse.xtext.parser.antlr.LexerProvider;
+import org.eclipse.xtext.resource.IContainer;
+import org.eclipse.xtext.resource.ILocationInFileProvider;
+import org.eclipse.xtext.resource.IResourceDescriptions;
+import org.eclipse.xtext.resource.containers.IAllContainersState;
+import org.eclipse.xtext.resource.containers.ResourceSetBasedAllContainersStateProvider;
+import org.eclipse.xtext.resource.containers.StateBasedContainerManager;
+import org.eclipse.xtext.resource.impl.ResourceDescriptionsProvider;
+import org.eclipse.xtext.resource.impl.ResourceSetBasedResourceDescriptions;
+import org.eclipse.xtext.scoping.IGlobalScopeProvider;
+import org.eclipse.xtext.scoping.IScopeProvider;
+import org.eclipse.xtext.scoping.IgnoreCaseLinking;
+import org.eclipse.xtext.scoping.impl.AbstractDeclarativeScopeProvider;
+import org.eclipse.xtext.serializer.ISerializer;
+import org.eclipse.xtext.serializer.impl.Serializer;
+import org.eclipse.xtext.serializer.sequencer.ISemanticSequencer;
+import org.eclipse.xtext.serializer.sequencer.ISyntacticSequencer;
+import org.eclipse.xtext.service.SingletonBinding;
+import org.eclipse.xtext.validation.IResourceValidator;
+import org.eclipse.xtext.xbase.annotations.DefaultXbaseWithAnnotationsRuntimeModule;
+import org.eclipse.xtext.xbase.annotations.validation.DerivedStateAwareResourceValidator;
+import org.eclipse.xtext.xbase.jvmmodel.IJvmModelInferrer;
+import org.eclipse.xtext.xbase.jvmmodel.JvmLocationInFileProvider;
+import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider;
+import org.eclipse.xtext.xbase.scoping.XbaseQualifiedNameProvider;
+import org.eclipse.xtext.xbase.scoping.batch.IBatchScopeProvider;
+import org.eclipse.xtext.xbase.typesystem.internal.DefaultBatchTypeResolver;
+import org.eclipse.xtext.xbase.typesystem.internal.DefaultReentrantTypeResolver;
+import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareBatchTypeResolver;
+import org.eclipse.xtext.xbase.typesystem.internal.LogicalContainerAwareReentrantTypeResolver;
+import org.eclipse.xtext.xbase.validation.FeatureNameValidator;
+import org.eclipse.xtext.xbase.validation.LogicalContainerAwareFeatureNameValidator;
+
+/**
+ * Manual modifications go to {@link OXtypeRuntimeModule}.
+ */
+@SuppressWarnings("all")
+public abstract class AbstractOXtypeRuntimeModule extends DefaultXbaseWithAnnotationsRuntimeModule {
+
+	protected Properties properties = null;
+
+	@Override
+	public void configure(Binder binder) {
+		properties = tryBindProperties(binder, "org/eclipse/osbp/xtext/oxtype/OXtype.properties");
+		super.configure(binder);
+	}
+	
+	public void configureLanguageName(Binder binder) {
+		binder.bind(String.class).annotatedWith(Names.named(Constants.LANGUAGE_NAME)).toInstance("org.eclipse.osbp.xtext.oxtype.OXtype");
+	}
+	
+	public void configureFileExtensions(Binder binder) {
+		if (properties == null || properties.getProperty(Constants.FILE_EXTENSIONS) == null)
+			binder.bind(String.class).annotatedWith(Names.named(Constants.FILE_EXTENSIONS)).toInstance("oxtype");
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2
+	public ClassLoader bindClassLoaderToInstance() {
+		return getClass().getClassLoader();
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.grammarAccess.GrammarAccessFragment2
+	public Class<? extends IGrammarAccess> bindIGrammarAccess() {
+		return OXtypeGrammarAccess.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+	public Class<? extends ISemanticSequencer> bindISemanticSequencer() {
+		return OXtypeSemanticSequencer.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+	public Class<? extends ISyntacticSequencer> bindISyntacticSequencer() {
+		return OXtypeSyntacticSequencer.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.serializer.SerializerFragment2
+	public Class<? extends ISerializer> bindISerializer() {
+		return Serializer.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends IParser> bindIParser() {
+		return OXtypeParser.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends ITokenToStringConverter> bindITokenToStringConverter() {
+		return AntlrTokenToStringConverter.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends IAntlrTokenFileProvider> bindIAntlrTokenFileProvider() {
+		return OXtypeAntlrTokenFileProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends Lexer> bindLexer() {
+		return InternalOXtypeLexer.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Class<? extends ITokenDefProvider> bindITokenDefProvider() {
+		return AntlrTokenDefProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public Provider<? extends InternalOXtypeLexer> provideInternalOXtypeLexer() {
+		return LexerProvider.create(InternalOXtypeLexer.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.parser.antlr.XtextAntlrGeneratorFragment2
+	public void configureRuntimeLexer(Binder binder) {
+		binder.bind(Lexer.class)
+			.annotatedWith(Names.named(LexerBindings.RUNTIME))
+			.to(InternalOXtypeLexer.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.validation.ValidatorFragment2
+	@SingletonBinding(eager=true)
+	public Class<? extends OXtypeValidator> bindOXtypeValidator() {
+		return OXtypeValidator.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+	public Class<? extends IBatchScopeProvider> bindIBatchScopeProvider() {
+		return OXtypeScopeProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+	public void configureIScopeProviderDelegate(Binder binder) {
+		binder.bind(IScopeProvider.class).annotatedWith(Names.named(AbstractDeclarativeScopeProvider.NAMED_DELEGATE)).to(XImportSectionNamespaceScopeProvider.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.scoping.ImportNamespacesScopingFragment2
+	public void configureIgnoreCaseLinking(Binder binder) {
+		binder.bindConstant().annotatedWith(IgnoreCaseLinking.class).to(false);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public Class<? extends IContainer.Manager> bindIContainer$Manager() {
+		return StateBasedContainerManager.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public Class<? extends IAllContainersState.Provider> bindIAllContainersState$Provider() {
+		return ResourceSetBasedAllContainersStateProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public void configureIResourceDescriptions(Binder binder) {
+		binder.bind(IResourceDescriptions.class).to(ResourceSetBasedResourceDescriptions.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.builder.BuilderIntegrationFragment2
+	public void configureIResourceDescriptionsPersisted(Binder binder) {
+		binder.bind(IResourceDescriptions.class).annotatedWith(Names.named(ResourceDescriptionsProvider.PERSISTED_DESCRIPTIONS)).to(ResourceSetBasedResourceDescriptions.class);
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IQualifiedNameProvider> bindIQualifiedNameProvider() {
+		return XbaseQualifiedNameProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends ILocationInFileProvider> bindILocationInFileProvider() {
+		return JvmLocationInFileProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IGlobalScopeProvider> bindIGlobalScopeProvider() {
+		return TypesAwareDefaultGlobalScopeProvider.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends FeatureNameValidator> bindFeatureNameValidator() {
+		return LogicalContainerAwareFeatureNameValidator.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends DefaultBatchTypeResolver> bindDefaultBatchTypeResolver() {
+		return LogicalContainerAwareBatchTypeResolver.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends DefaultReentrantTypeResolver> bindDefaultReentrantTypeResolver() {
+		return LogicalContainerAwareReentrantTypeResolver.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IResourceValidator> bindIResourceValidator() {
+		return DerivedStateAwareResourceValidator.class;
+	}
+	
+	// contributed by org.eclipse.xtext.xtext.generator.xbase.XbaseGeneratorFragment2
+	public Class<? extends IJvmModelInferrer> bindIJvmModelInferrer() {
+		return OXtypeJvmModelInferrer.class;
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetupGenerated.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetupGenerated.java
new file mode 100644
index 0000000..25fd405
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetupGenerated.java
@@ -0,0 +1,37 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+import org.eclipse.emf.ecore.resource.Resource;
+import org.eclipse.xtext.ISetup;
+import org.eclipse.xtext.resource.IResourceFactory;
+import org.eclipse.xtext.resource.IResourceServiceProvider;
+import org.eclipse.xtext.xbase.annotations.XbaseWithAnnotationsStandaloneSetup;
+
+@SuppressWarnings("all")
+public class OXtypeStandaloneSetupGenerated implements ISetup {
+
+	@Override
+	public Injector createInjectorAndDoEMFRegistration() {
+		XbaseWithAnnotationsStandaloneSetup.doSetup();
+
+		Injector injector = createInjector();
+		register(injector);
+		return injector;
+	}
+	
+	public Injector createInjector() {
+		return Guice.createInjector(new OXtypeRuntimeModule());
+	}
+	
+	public void register(Injector injector) {
+		IResourceFactory resourceFactory = injector.getInstance(IResourceFactory.class);
+		IResourceServiceProvider serviceProvider = injector.getInstance(IResourceServiceProvider.class);
+		
+		Resource.Factory.Registry.INSTANCE.getExtensionToFactoryMap().put("oxtype", resourceFactory);
+		IResourceServiceProvider.Registry.INSTANCE.getExtensionToFactoryMap().put("oxtype", serviceProvider);
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeAntlrTokenFileProvider.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeAntlrTokenFileProvider.java
new file mode 100644
index 0000000..580e022
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeAntlrTokenFileProvider.java
@@ -0,0 +1,16 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.parser.antlr;
+
+import java.io.InputStream;
+import org.eclipse.xtext.parser.antlr.IAntlrTokenFileProvider;
+
+public class OXtypeAntlrTokenFileProvider implements IAntlrTokenFileProvider {
+
+	@Override
+	public InputStream getAntlrTokenFile() {
+		ClassLoader classLoader = getClass().getClassLoader();
+		return classLoader.getResourceAsStream("org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens");
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeParser.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeParser.java
new file mode 100644
index 0000000..0ace959
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/OXtypeParser.java
@@ -0,0 +1,40 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.parser.antlr;
+
+import com.google.inject.Inject;
+import org.eclipse.osbp.xtext.oxtype.parser.antlr.internal.InternalOXtypeParser;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.parser.antlr.AbstractAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+
+public class OXtypeParser extends AbstractAntlrParser {
+
+	@Inject
+	private OXtypeGrammarAccess grammarAccess;
+
+	@Override
+	protected void setInitialHiddenTokens(XtextTokenStream tokenStream) {
+		tokenStream.setInitialHiddenTokens("RULE_WS", "RULE_ML_COMMENT", "RULE_SL_COMMENT");
+	}
+	
+
+	@Override
+	protected InternalOXtypeParser createParser(XtextTokenStream stream) {
+		return new InternalOXtypeParser(stream, getGrammarAccess());
+	}
+
+	@Override 
+	protected String getDefaultRuleName() {
+		return "XImportDeclaration";
+	}
+
+	public OXtypeGrammarAccess getGrammarAccess() {
+		return this.grammarAccess;
+	}
+
+	public void setGrammarAccess(OXtypeGrammarAccess grammarAccess) {
+		this.grammarAccess = grammarAccess;
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.g b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.g
new file mode 100644
index 0000000..d388467
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.g
@@ -0,0 +1,6904 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+grammar InternalOXtype;
+
+options {
+	superClass=AbstractInternalAntlrParser;
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.oxtype.parser.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.parser.antlr.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.oxtype.parser.antlr.internal;
+
+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.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+}
+
+@parser::members {
+
+ 	private OXtypeGrammarAccess grammarAccess;
+
+    public InternalOXtypeParser(TokenStream input, OXtypeGrammarAccess grammarAccess) {
+        this(input);
+        this.grammarAccess = grammarAccess;
+        registerRules(grammarAccess.getGrammar());
+    }
+
+    @Override
+    protected String getFirstRuleName() {
+    	return "XImportDeclaration";
+   	}
+
+   	@Override
+   	protected OXtypeGrammarAccess getGrammarAccess() {
+   		return grammarAccess;
+   	}
+
+}
+
+@rulecatch {
+    catch (RecognitionException re) {
+        recover(input,re);
+        appendSkippedTokens();
+    }
+}
+
+// Entry rule entryRuleXImportDeclaration
+entryRuleXImportDeclaration returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXImportDeclarationRule()); }
+	iv_ruleXImportDeclaration=ruleXImportDeclaration
+	{ $current=$iv_ruleXImportDeclaration.current; }
+	EOF;
+
+// Rule XImportDeclaration
+ruleXImportDeclaration returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='import'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXImportDeclarationAccess().getImportKeyword_1());
+		}
+		(
+			(
+				(
+					(
+						lv_static_2_0='static'
+						{
+							newLeafNode(lv_static_2_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+						}
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXImportDeclarationRule());
+							}
+							setWithLastConsumed($current, "static", true, "static");
+						}
+					)
+				)
+				(
+					(
+						lv_extension_3_0='extension'
+						{
+							newLeafNode(lv_extension_3_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+						}
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXImportDeclarationRule());
+							}
+							setWithLastConsumed($current, "extension", true, "extension");
+						}
+					)
+				)?
+				(
+					(
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXImportDeclarationRule());
+							}
+						}
+						{
+							newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0());
+						}
+						ruleQualifiedNameInStaticImport
+						{
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					(
+						(
+							lv_wildcard_5_0='*'
+							{
+								newLeafNode(lv_wildcard_5_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+							}
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXImportDeclarationRule());
+								}
+								setWithLastConsumed($current, "wildcard", true, "*");
+							}
+						)
+					)
+					    |
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0());
+							}
+							lv_memberName_6_0=ruleValidID
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+								}
+								set(
+									$current,
+									"memberName",
+									lv_memberName_6_0,
+									"org.eclipse.xtext.xbase.Xtype.ValidID");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			    |
+			(
+				(
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXImportDeclarationRule());
+						}
+					}
+					{
+						newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0());
+					}
+					ruleQualifiedName
+					{
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			    |
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0());
+					}
+					lv_importedNamespace_8_0=ruleQualifiedNameWithWildcard
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+						}
+						set(
+							$current,
+							"importedNamespace",
+							lv_importedNamespace_8_0,
+							"org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			    |
+			(
+				(
+					(
+						lv_fqnImport_9_0='ns'
+						{
+							newLeafNode(lv_fqnImport_9_0, grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+						}
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXImportDeclarationRule());
+							}
+							setWithLastConsumed($current, "fqnImport", true, "ns");
+						}
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0());
+						}
+						lv_importedFullyQualifiedName_10_0=ruleQualifiedName
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+							}
+							set(
+								$current,
+								"importedFullyQualifiedName",
+								lv_importedFullyQualifiedName_10_0,
+								"org.eclipse.xtext.xbase.Xbase.QualifiedName");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+		)
+		(
+			otherlv_11=';'
+			{
+				newLeafNode(otherlv_11, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+			}
+		)?
+	)
+;
+
+// Entry rule entryRuleXAnnotation
+entryRuleXAnnotation returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAnnotationRule()); }
+	iv_ruleXAnnotation=ruleXAnnotation
+	{ $current=$iv_ruleXAnnotation.current; }
+	EOF;
+
+// Rule XAnnotation
+ruleXAnnotation returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXAnnotationAccess().getXAnnotationAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='@'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+		}
+		(
+			(
+				{
+					if ($current==null) {
+						$current = createModelElement(grammarAccess.getXAnnotationRule());
+					}
+				}
+				{
+					newCompositeNode(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+				}
+				ruleQualifiedName
+				{
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				('(')=>
+				otherlv_3='('
+				{
+					newLeafNode(otherlv_3, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+				}
+			)
+			(
+				(
+					(
+						((
+							(
+								(
+									ruleValidID
+								)
+							)
+							'='
+						)
+						)=>
+						(
+							{
+								newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+							}
+							lv_elementValuePairs_4_0=ruleXAnnotationElementValuePair
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+								}
+								add(
+									$current,
+									"elementValuePairs",
+									lv_elementValuePairs_4_0,
+									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_5=','
+						{
+							newLeafNode(otherlv_5, grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+						}
+						(
+							((
+								(
+									(
+										ruleValidID
+									)
+								)
+								'='
+							)
+							)=>
+							(
+								{
+									newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+								}
+								lv_elementValuePairs_6_0=ruleXAnnotationElementValuePair
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+									}
+									add(
+										$current,
+										"elementValuePairs",
+										lv_elementValuePairs_6_0,
+										"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+				)
+				    |
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+						}
+						lv_value_7_0=ruleXAnnotationElementValueOrCommaList
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+							}
+							set(
+								$current,
+								"value",
+								lv_value_7_0,
+								"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValueOrCommaList");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)?
+			otherlv_8=')'
+			{
+				newLeafNode(otherlv_8, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+			}
+		)?
+	)
+;
+
+// Entry rule entryRuleXAnnotationElementValuePair
+entryRuleXAnnotationElementValuePair returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAnnotationElementValuePairRule()); }
+	iv_ruleXAnnotationElementValuePair=ruleXAnnotationElementValuePair
+	{ $current=$iv_ruleXAnnotationElementValuePair.current; }
+	EOF;
+
+// Rule XAnnotationElementValuePair
+ruleXAnnotationElementValuePair returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			((
+				(
+					(
+						ruleValidID
+					)
+				)
+				'='
+			)
+			)=>
+			(
+				(
+					(
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXAnnotationElementValuePairRule());
+							}
+						}
+						{
+							newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+						}
+						ruleValidID
+						{
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				otherlv_1='='
+				{
+					newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+				}
+			)
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+				}
+				lv_value_2_0=ruleXAnnotationElementValue
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXAnnotationElementValuePairRule());
+					}
+					set(
+						$current,
+						"value",
+						lv_value_2_0,
+						"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValue");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXAnnotationElementValueOrCommaList
+entryRuleXAnnotationElementValueOrCommaList returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListRule()); }
+	iv_ruleXAnnotationElementValueOrCommaList=ruleXAnnotationElementValueOrCommaList
+	{ $current=$iv_ruleXAnnotationElementValueOrCommaList.current; }
+	EOF;
+
+// Rule XAnnotationElementValueOrCommaList
+ruleXAnnotationElementValueOrCommaList returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				((
+					(
+					)
+					'#'
+					'['
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElement(
+								grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0(),
+								$current);
+						}
+					)
+					otherlv_1='#'
+					{
+						newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+					}
+					otherlv_2='['
+					{
+						newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+					}
+				)
+			)
+			(
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+						}
+						lv_elements_3_0=ruleXAnnotationOrExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+							}
+							add(
+								$current,
+								"elements",
+								lv_elements_3_0,
+								"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					otherlv_4=','
+					{
+						newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+					}
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+							}
+							lv_elements_5_0=ruleXAnnotationOrExpression
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+								}
+								add(
+									$current,
+									"elements",
+									lv_elements_5_0,
+									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)*
+			)?
+			otherlv_6=']'
+			{
+				newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+			}
+		)
+		    |
+		(
+			{
+				newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+			}
+			this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression
+			{
+				$current = $this_XAnnotationOrExpression_7.current;
+				afterParserOrEnumRuleCall();
+			}
+			(
+				(
+					{
+						$current = forceCreateModelElementAndAdd(
+							grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0(),
+							$current);
+					}
+				)
+				(
+					otherlv_9=','
+					{
+						newLeafNode(otherlv_9, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+					}
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+							}
+							lv_elements_10_0=ruleXAnnotationOrExpression
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+								}
+								add(
+									$current,
+									"elements",
+									lv_elements_10_0,
+									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)+
+			)?
+		)
+	)
+;
+
+// Entry rule entryRuleXAnnotationElementValue
+entryRuleXAnnotationElementValue returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAnnotationElementValueRule()); }
+	iv_ruleXAnnotationElementValue=ruleXAnnotationElementValue
+	{ $current=$iv_ruleXAnnotationElementValue.current; }
+	EOF;
+
+// Rule XAnnotationElementValue
+ruleXAnnotationElementValue returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				((
+					(
+					)
+					'#'
+					'['
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElement(
+								grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0(),
+								$current);
+						}
+					)
+					otherlv_1='#'
+					{
+						newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+					}
+					otherlv_2='['
+					{
+						newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+					}
+				)
+			)
+			(
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+						}
+						lv_elements_3_0=ruleXAnnotationOrExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+							}
+							add(
+								$current,
+								"elements",
+								lv_elements_3_0,
+								"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					otherlv_4=','
+					{
+						newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+					}
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+							}
+							lv_elements_5_0=ruleXAnnotationOrExpression
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+								}
+								add(
+									$current,
+									"elements",
+									lv_elements_5_0,
+									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)*
+			)?
+			otherlv_6=']'
+			{
+				newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+			}
+		)
+		    |
+		{
+			newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+		}
+		this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression
+		{
+			$current = $this_XAnnotationOrExpression_7.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleXAnnotationOrExpression
+entryRuleXAnnotationOrExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAnnotationOrExpressionRule()); }
+	iv_ruleXAnnotationOrExpression=ruleXAnnotationOrExpression
+	{ $current=$iv_ruleXAnnotationOrExpression.current; }
+	EOF;
+
+// Rule XAnnotationOrExpression
+ruleXAnnotationOrExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+		}
+		this_XAnnotation_0=ruleXAnnotation
+		{
+			$current = $this_XAnnotation_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+		}
+		this_XExpression_1=ruleXExpression
+		{
+			$current = $this_XExpression_1.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleXExpression
+entryRuleXExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXExpressionRule()); }
+	iv_ruleXExpression=ruleXExpression
+	{ $current=$iv_ruleXExpression.current; }
+	EOF;
+
+// Rule XExpression
+ruleXExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	{
+		newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+	}
+	this_XAssignment_0=ruleXAssignment
+	{
+		$current = $this_XAssignment_0.current;
+		afterParserOrEnumRuleCall();
+	}
+;
+
+// Entry rule entryRuleXAssignment
+entryRuleXAssignment returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAssignmentRule()); }
+	iv_ruleXAssignment=ruleXAssignment
+	{ $current=$iv_ruleXAssignment.current; }
+	EOF;
+
+// Rule XAssignment
+ruleXAssignment returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				{
+					$current = forceCreateModelElement(
+						grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(),
+						$current);
+				}
+			)
+			(
+				(
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXAssignmentRule());
+						}
+					}
+					{
+						newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+					}
+					ruleFeatureCallID
+					{
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			{
+				newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+			}
+			ruleOpSingleAssign
+			{
+				afterParserOrEnumRuleCall();
+			}
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+					}
+					lv_value_3_0=ruleXAssignment
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+						}
+						set(
+							$current,
+							"value",
+							lv_value_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XAssignment");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)
+		    |
+		(
+			{
+				newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+			}
+			this_XOrExpression_4=ruleXOrExpression
+			{
+				$current = $this_XOrExpression_4.current;
+				afterParserOrEnumRuleCall();
+			}
+			(
+				(
+					((
+						(
+						)
+						(
+							(
+								ruleOpMultiAssign
+							)
+						)
+					)
+					)=>
+					(
+						(
+							{
+								$current = forceCreateModelElementAndSet(
+									grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+									$current);
+							}
+						)
+						(
+							(
+								{
+									if ($current==null) {
+										$current = createModelElement(grammarAccess.getXAssignmentRule());
+									}
+								}
+								{
+									newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+								}
+								ruleOpMultiAssign
+								{
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+						}
+						lv_rightOperand_7_0=ruleXAssignment
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+							}
+							set(
+								$current,
+								"rightOperand",
+								lv_rightOperand_7_0,
+								"org.eclipse.xtext.xbase.Xbase.XAssignment");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)?
+		)
+	)
+;
+
+// Entry rule entryRuleOpSingleAssign
+entryRuleOpSingleAssign returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpSingleAssignRule()); }
+	iv_ruleOpSingleAssign=ruleOpSingleAssign
+	{ $current=$iv_ruleOpSingleAssign.current.getText(); }
+	EOF;
+
+// Rule OpSingleAssign
+ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	kw='='
+	{
+		$current.merge(kw);
+		newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+	}
+;
+
+// Entry rule entryRuleOpMultiAssign
+entryRuleOpMultiAssign returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpMultiAssignRule()); }
+	iv_ruleOpMultiAssign=ruleOpMultiAssign
+	{ $current=$iv_ruleOpMultiAssign.current.getText(); }
+	EOF;
+
+// Rule OpMultiAssign
+ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='+='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+		}
+		    |
+		kw='-='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+		}
+		    |
+		kw='*='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+		}
+		    |
+		kw='/='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+		}
+		    |
+		kw='%='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+		}
+		    |
+		(
+			kw='<'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+			}
+			kw='<'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+			}
+			kw='='
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+			}
+		)
+		    |
+		(
+			kw='>'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+			}
+			(
+				kw='>'
+				{
+					$current.merge(kw);
+					newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+				}
+			)?
+			kw='>='
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+			}
+		)
+	)
+;
+
+// Entry rule entryRuleXOrExpression
+entryRuleXOrExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXOrExpressionRule()); }
+	iv_ruleXOrExpression=ruleXOrExpression
+	{ $current=$iv_ruleXOrExpression.current; }
+	EOF;
+
+// Rule XOrExpression
+ruleXOrExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+		}
+		this_XAndExpression_0=ruleXAndExpression
+		{
+			$current = $this_XAndExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					(
+						(
+							ruleOpOr
+						)
+					)
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+								$current);
+						}
+					)
+					(
+						(
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXOrExpressionRule());
+								}
+							}
+							{
+								newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+							}
+							ruleOpOr
+							{
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+					}
+					lv_rightOperand_3_0=ruleXAndExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXOrExpressionRule());
+						}
+						set(
+							$current,
+							"rightOperand",
+							lv_rightOperand_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XAndExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpOr
+entryRuleOpOr returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpOrRule()); }
+	iv_ruleOpOr=ruleOpOr
+	{ $current=$iv_ruleOpOr.current.getText(); }
+	EOF;
+
+// Rule OpOr
+ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	kw='||'
+	{
+		$current.merge(kw);
+		newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+	}
+;
+
+// Entry rule entryRuleXAndExpression
+entryRuleXAndExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAndExpressionRule()); }
+	iv_ruleXAndExpression=ruleXAndExpression
+	{ $current=$iv_ruleXAndExpression.current; }
+	EOF;
+
+// Rule XAndExpression
+ruleXAndExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+		}
+		this_XEqualityExpression_0=ruleXEqualityExpression
+		{
+			$current = $this_XEqualityExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					(
+						(
+							ruleOpAnd
+						)
+					)
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+								$current);
+						}
+					)
+					(
+						(
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXAndExpressionRule());
+								}
+							}
+							{
+								newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+							}
+							ruleOpAnd
+							{
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+					}
+					lv_rightOperand_3_0=ruleXEqualityExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXAndExpressionRule());
+						}
+						set(
+							$current,
+							"rightOperand",
+							lv_rightOperand_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XEqualityExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpAnd
+entryRuleOpAnd returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpAndRule()); }
+	iv_ruleOpAnd=ruleOpAnd
+	{ $current=$iv_ruleOpAnd.current.getText(); }
+	EOF;
+
+// Rule OpAnd
+ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	kw='&&'
+	{
+		$current.merge(kw);
+		newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+	}
+;
+
+// Entry rule entryRuleXEqualityExpression
+entryRuleXEqualityExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXEqualityExpressionRule()); }
+	iv_ruleXEqualityExpression=ruleXEqualityExpression
+	{ $current=$iv_ruleXEqualityExpression.current; }
+	EOF;
+
+// Rule XEqualityExpression
+ruleXEqualityExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+		}
+		this_XRelationalExpression_0=ruleXRelationalExpression
+		{
+			$current = $this_XRelationalExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					(
+						(
+							ruleOpEquality
+						)
+					)
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+								$current);
+						}
+					)
+					(
+						(
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXEqualityExpressionRule());
+								}
+							}
+							{
+								newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+							}
+							ruleOpEquality
+							{
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+					}
+					lv_rightOperand_3_0=ruleXRelationalExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule());
+						}
+						set(
+							$current,
+							"rightOperand",
+							lv_rightOperand_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XRelationalExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpEquality
+entryRuleOpEquality returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpEqualityRule()); }
+	iv_ruleOpEquality=ruleOpEquality
+	{ $current=$iv_ruleOpEquality.current.getText(); }
+	EOF;
+
+// Rule OpEquality
+ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='=='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+		}
+		    |
+		kw='!='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+		}
+		    |
+		kw='==='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+		}
+		    |
+		kw='!=='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+		}
+	)
+;
+
+// Entry rule entryRuleXRelationalExpression
+entryRuleXRelationalExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXRelationalExpressionRule()); }
+	iv_ruleXRelationalExpression=ruleXRelationalExpression
+	{ $current=$iv_ruleXRelationalExpression.current; }
+	EOF;
+
+// Rule XRelationalExpression
+ruleXRelationalExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+		}
+		this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression
+		{
+			$current = $this_XOtherOperatorExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				(
+					((
+						(
+						)
+						'instanceof'
+					)
+					)=>
+					(
+						(
+							{
+								$current = forceCreateModelElementAndSet(
+									grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(),
+									$current);
+							}
+						)
+						otherlv_2='instanceof'
+						{
+							newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+						}
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+						}
+						lv_type_3_0=ruleJvmTypeReference
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+							}
+							set(
+								$current,
+								"type",
+								lv_type_3_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+			    |
+			(
+				(
+					((
+						(
+						)
+						(
+							(
+								ruleOpCompare
+							)
+						)
+					)
+					)=>
+					(
+						(
+							{
+								$current = forceCreateModelElementAndSet(
+									grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+									$current);
+							}
+						)
+						(
+							(
+								{
+									if ($current==null) {
+										$current = createModelElement(grammarAccess.getXRelationalExpressionRule());
+									}
+								}
+								{
+									newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+								}
+								ruleOpCompare
+								{
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+						}
+						lv_rightOperand_6_0=ruleXOtherOperatorExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+							}
+							set(
+								$current,
+								"rightOperand",
+								lv_rightOperand_6_0,
+								"org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpCompare
+entryRuleOpCompare returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpCompareRule()); }
+	iv_ruleOpCompare=ruleOpCompare
+	{ $current=$iv_ruleOpCompare.current.getText(); }
+	EOF;
+
+// Rule OpCompare
+ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='>='
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+		}
+		    |
+		(
+			kw='<'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+			}
+			kw='='
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+			}
+		)
+		    |
+		kw='>'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+		}
+		    |
+		kw='<'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+		}
+	)
+;
+
+// Entry rule entryRuleXOtherOperatorExpression
+entryRuleXOtherOperatorExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); }
+	iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression
+	{ $current=$iv_ruleXOtherOperatorExpression.current; }
+	EOF;
+
+// Rule XOtherOperatorExpression
+ruleXOtherOperatorExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+		}
+		this_XAdditiveExpression_0=ruleXAdditiveExpression
+		{
+			$current = $this_XAdditiveExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					(
+						(
+							ruleOpOther
+						)
+					)
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+								$current);
+						}
+					)
+					(
+						(
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule());
+								}
+							}
+							{
+								newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+							}
+							ruleOpOther
+							{
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+					}
+					lv_rightOperand_3_0=ruleXAdditiveExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule());
+						}
+						set(
+							$current,
+							"rightOperand",
+							lv_rightOperand_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XAdditiveExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpOther
+entryRuleOpOther returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpOtherRule()); }
+	iv_ruleOpOther=ruleOpOther
+	{ $current=$iv_ruleOpOther.current.getText(); }
+	EOF;
+
+// Rule OpOther
+ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='->'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+		}
+		    |
+		kw='..<'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+		}
+		    |
+		(
+			kw='>'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+			}
+			kw='..'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+			}
+		)
+		    |
+		kw='..'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+		}
+		    |
+		kw='=>'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+		}
+		    |
+		(
+			kw='>'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+			}
+			(
+				(
+					((
+						'>'
+						'>'
+					)
+					)=>
+					(
+						kw='>'
+						{
+							$current.merge(kw);
+							newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+						}
+						kw='>'
+						{
+							$current.merge(kw);
+							newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+						}
+					)
+				)
+				    |
+				kw='>'
+				{
+					$current.merge(kw);
+					newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+				}
+			)
+		)
+		    |
+		(
+			kw='<'
+			{
+				$current.merge(kw);
+				newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+			}
+			(
+				(
+					((
+						'<'
+						'<'
+					)
+					)=>
+					(
+						kw='<'
+						{
+							$current.merge(kw);
+							newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+						}
+						kw='<'
+						{
+							$current.merge(kw);
+							newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+						}
+					)
+				)
+				    |
+				kw='<'
+				{
+					$current.merge(kw);
+					newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+				}
+				    |
+				kw='=>'
+				{
+					$current.merge(kw);
+					newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+				}
+			)
+		)
+		    |
+		kw='<>'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+		}
+		    |
+		kw='?:'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+		}
+	)
+;
+
+// Entry rule entryRuleXAdditiveExpression
+entryRuleXAdditiveExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); }
+	iv_ruleXAdditiveExpression=ruleXAdditiveExpression
+	{ $current=$iv_ruleXAdditiveExpression.current; }
+	EOF;
+
+// Rule XAdditiveExpression
+ruleXAdditiveExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+		}
+		this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression
+		{
+			$current = $this_XMultiplicativeExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					(
+						(
+							ruleOpAdd
+						)
+					)
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+								$current);
+						}
+					)
+					(
+						(
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXAdditiveExpressionRule());
+								}
+							}
+							{
+								newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+							}
+							ruleOpAdd
+							{
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+					}
+					lv_rightOperand_3_0=ruleXMultiplicativeExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule());
+						}
+						set(
+							$current,
+							"rightOperand",
+							lv_rightOperand_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpAdd
+entryRuleOpAdd returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpAddRule()); }
+	iv_ruleOpAdd=ruleOpAdd
+	{ $current=$iv_ruleOpAdd.current.getText(); }
+	EOF;
+
+// Rule OpAdd
+ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='+'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+		}
+		    |
+		kw='-'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+		}
+	)
+;
+
+// Entry rule entryRuleXMultiplicativeExpression
+entryRuleXMultiplicativeExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); }
+	iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression
+	{ $current=$iv_ruleXMultiplicativeExpression.current; }
+	EOF;
+
+// Rule XMultiplicativeExpression
+ruleXMultiplicativeExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+		}
+		this_XUnaryOperation_0=ruleXUnaryOperation
+		{
+			$current = $this_XUnaryOperation_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					(
+						(
+							ruleOpMulti
+						)
+					)
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+								$current);
+						}
+					)
+					(
+						(
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule());
+								}
+							}
+							{
+								newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+							}
+							ruleOpMulti
+							{
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+					}
+					lv_rightOperand_3_0=ruleXUnaryOperation
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule());
+						}
+						set(
+							$current,
+							"rightOperand",
+							lv_rightOperand_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleOpMulti
+entryRuleOpMulti returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpMultiRule()); }
+	iv_ruleOpMulti=ruleOpMulti
+	{ $current=$iv_ruleOpMulti.current.getText(); }
+	EOF;
+
+// Rule OpMulti
+ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='*'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+		}
+		    |
+		kw='**'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+		}
+		    |
+		kw='/'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+		}
+		    |
+		kw='%'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+		}
+	)
+;
+
+// Entry rule entryRuleXUnaryOperation
+entryRuleXUnaryOperation returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXUnaryOperationRule()); }
+	iv_ruleXUnaryOperation=ruleXUnaryOperation
+	{ $current=$iv_ruleXUnaryOperation.current; }
+	EOF;
+
+// Rule XUnaryOperation
+ruleXUnaryOperation returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				{
+					$current = forceCreateModelElement(
+						grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(),
+						$current);
+				}
+			)
+			(
+				(
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXUnaryOperationRule());
+						}
+					}
+					{
+						newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+					}
+					ruleOpUnary
+					{
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+					}
+					lv_operand_2_0=ruleXUnaryOperation
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXUnaryOperationRule());
+						}
+						set(
+							$current,
+							"operand",
+							lv_operand_2_0,
+							"org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)
+		    |
+		{
+			newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+		}
+		this_XCastedExpression_3=ruleXCastedExpression
+		{
+			$current = $this_XCastedExpression_3.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleOpUnary
+entryRuleOpUnary returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpUnaryRule()); }
+	iv_ruleOpUnary=ruleOpUnary
+	{ $current=$iv_ruleOpUnary.current.getText(); }
+	EOF;
+
+// Rule OpUnary
+ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='!'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+		}
+		    |
+		kw='-'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+		}
+		    |
+		kw='+'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+		}
+	)
+;
+
+// Entry rule entryRuleXCastedExpression
+entryRuleXCastedExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXCastedExpressionRule()); }
+	iv_ruleXCastedExpression=ruleXCastedExpression
+	{ $current=$iv_ruleXCastedExpression.current; }
+	EOF;
+
+// Rule XCastedExpression
+ruleXCastedExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+		}
+		this_XPostfixOperation_0=ruleXPostfixOperation
+		{
+			$current = $this_XPostfixOperation_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				((
+					(
+					)
+					'as'
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(),
+								$current);
+						}
+					)
+					otherlv_2='as'
+					{
+						newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+					}
+				)
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+					}
+					lv_type_3_0=ruleJvmTypeReference
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXCastedExpressionRule());
+						}
+						set(
+							$current,
+							"type",
+							lv_type_3_0,
+							"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleXPostfixOperation
+entryRuleXPostfixOperation returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXPostfixOperationRule()); }
+	iv_ruleXPostfixOperation=ruleXPostfixOperation
+	{ $current=$iv_ruleXPostfixOperation.current; }
+	EOF;
+
+// Rule XPostfixOperation
+ruleXPostfixOperation returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+		}
+		this_XMemberFeatureCall_0=ruleXMemberFeatureCall
+		{
+			$current = $this_XMemberFeatureCall_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			((
+				(
+				)
+				(
+					(
+						ruleOpPostfix
+					)
+				)
+			)
+			)=>
+			(
+				(
+					{
+						$current = forceCreateModelElementAndSet(
+							grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(),
+							$current);
+					}
+				)
+				(
+					(
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXPostfixOperationRule());
+							}
+						}
+						{
+							newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+						}
+						ruleOpPostfix
+						{
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleOpPostfix
+entryRuleOpPostfix returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getOpPostfixRule()); }
+	iv_ruleOpPostfix=ruleOpPostfix
+	{ $current=$iv_ruleOpPostfix.current.getText(); }
+	EOF;
+
+// Rule OpPostfix
+ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='++'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+		}
+		    |
+		kw='--'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+		}
+	)
+;
+
+// Entry rule entryRuleXMemberFeatureCall
+entryRuleXMemberFeatureCall returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); }
+	iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall
+	{ $current=$iv_ruleXMemberFeatureCall.current; }
+	EOF;
+
+// Rule XMemberFeatureCall
+ruleXMemberFeatureCall returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+		}
+		this_XPrimaryExpression_0=ruleXPrimaryExpression
+		{
+			$current = $this_XPrimaryExpression_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				(
+					((
+						(
+						)
+						(
+							'.'
+							    |
+							(
+								(
+									'::'
+								)
+							)
+						)
+						(
+							(
+								ruleFeatureCallID
+							)
+						)
+						ruleOpSingleAssign
+					)
+					)=>
+					(
+						(
+							{
+								$current = forceCreateModelElementAndSet(
+									grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(),
+									$current);
+							}
+						)
+						(
+							otherlv_2='.'
+							{
+								newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+							}
+							    |
+							(
+								(
+									lv_explicitStatic_3_0='::'
+									{
+										newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+									}
+									{
+										if ($current==null) {
+											$current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+										}
+										setWithLastConsumed($current, "explicitStatic", true, "::");
+									}
+								)
+							)
+						)
+						(
+							(
+								{
+									if ($current==null) {
+										$current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+									}
+								}
+								{
+									newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+								}
+								ruleFeatureCallID
+								{
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+						{
+							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+						}
+						ruleOpSingleAssign
+						{
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+						}
+						lv_value_6_0=ruleXAssignment
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+							}
+							set(
+								$current,
+								"value",
+								lv_value_6_0,
+								"org.eclipse.xtext.xbase.Xbase.XAssignment");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+			    |
+			(
+				(
+					((
+						(
+						)
+						(
+							'.'
+							    |
+							(
+								(
+									'?.'
+								)
+							)
+							    |
+							(
+								(
+									'::'
+								)
+							)
+						)
+					)
+					)=>
+					(
+						(
+							{
+								$current = forceCreateModelElementAndSet(
+									grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(),
+									$current);
+							}
+						)
+						(
+							otherlv_8='.'
+							{
+								newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+							}
+							    |
+							(
+								(
+									lv_nullSafe_9_0='?.'
+									{
+										newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+									}
+									{
+										if ($current==null) {
+											$current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+										}
+										setWithLastConsumed($current, "nullSafe", true, "?.");
+									}
+								)
+							)
+							    |
+							(
+								(
+									lv_explicitStatic_10_0='::'
+									{
+										newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+									}
+									{
+										if ($current==null) {
+											$current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+										}
+										setWithLastConsumed($current, "explicitStatic", true, "::");
+									}
+								)
+							)
+						)
+					)
+				)
+				(
+					otherlv_11='<'
+					{
+						newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+					}
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+							}
+							lv_typeArguments_12_0=ruleJvmArgumentTypeReference
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+								}
+								add(
+									$current,
+									"typeArguments",
+									lv_typeArguments_12_0,
+									"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_13=','
+						{
+							newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+								}
+								lv_typeArguments_14_0=ruleJvmArgumentTypeReference
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+									}
+									add(
+										$current,
+										"typeArguments",
+										lv_typeArguments_14_0,
+										"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+					otherlv_15='>'
+					{
+						newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+					}
+				)?
+				(
+					(
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+							}
+						}
+						{
+							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+						}
+						ruleIdOrSuper
+						{
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					(
+						((
+							'('
+						)
+						)=>
+						(
+							lv_explicitOperationCall_17_0='('
+							{
+								newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+							}
+							{
+								if ($current==null) {
+									$current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+								}
+								setWithLastConsumed($current, "explicitOperationCall", true, "(");
+							}
+						)
+					)
+					(
+						(
+							((
+								(
+								)
+								(
+									(
+										(
+											ruleJvmFormalParameter
+										)
+									)
+									(
+										','
+										(
+											(
+												ruleJvmFormalParameter
+											)
+										)
+									)*
+								)?
+								(
+									(
+										'|'
+									)
+								)
+							)
+							)=>
+							(
+								{
+									newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+								}
+								lv_memberCallArguments_18_0=ruleXShortClosure
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+									}
+									add(
+										$current,
+										"memberCallArguments",
+										lv_memberCallArguments_18_0,
+										"org.eclipse.xtext.xbase.Xbase.XShortClosure");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+						    |
+						(
+							(
+								(
+									{
+										newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+									}
+									lv_memberCallArguments_19_0=ruleXExpression
+									{
+										if ($current==null) {
+											$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+										}
+										add(
+											$current,
+											"memberCallArguments",
+											lv_memberCallArguments_19_0,
+											"org.eclipse.xtext.xbase.Xbase.XExpression");
+										afterParserOrEnumRuleCall();
+									}
+								)
+							)
+							(
+								otherlv_20=','
+								{
+									newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+								}
+								(
+									(
+										{
+											newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+										}
+										lv_memberCallArguments_21_0=ruleXExpression
+										{
+											if ($current==null) {
+												$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+											}
+											add(
+												$current,
+												"memberCallArguments",
+												lv_memberCallArguments_21_0,
+												"org.eclipse.xtext.xbase.Xbase.XExpression");
+											afterParserOrEnumRuleCall();
+										}
+									)
+								)
+							)*
+						)
+					)?
+					otherlv_22=')'
+					{
+						newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+					}
+				)?
+				(
+					((
+						(
+						)
+						'['
+					)
+					)=>
+					(
+						{
+							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+						}
+						lv_memberCallArguments_23_0=ruleXClosure
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+							}
+							add(
+								$current,
+								"memberCallArguments",
+								lv_memberCallArguments_23_0,
+								"org.eclipse.xtext.xbase.Xbase.XClosure");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)?
+			)
+		)*
+	)
+;
+
+// Entry rule entryRuleXPrimaryExpression
+entryRuleXPrimaryExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); }
+	iv_ruleXPrimaryExpression=ruleXPrimaryExpression
+	{ $current=$iv_ruleXPrimaryExpression.current; }
+	EOF;
+
+// Rule XPrimaryExpression
+ruleXPrimaryExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+		}
+		this_XConstructorCall_0=ruleXConstructorCall
+		{
+			$current = $this_XConstructorCall_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+		}
+		this_XBlockExpression_1=ruleXBlockExpression
+		{
+			$current = $this_XBlockExpression_1.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+		}
+		this_XSwitchExpression_2=ruleXSwitchExpression
+		{
+			$current = $this_XSwitchExpression_2.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		(
+			((
+				(
+				)
+				'synchronized'
+				'('
+			)
+			)=>
+			{
+				newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+			}
+			this_XSynchronizedExpression_3=ruleXSynchronizedExpression
+			{
+				$current = $this_XSynchronizedExpression_3.current;
+				afterParserOrEnumRuleCall();
+			}
+		)
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+		}
+		this_XFeatureCall_4=ruleXFeatureCall
+		{
+			$current = $this_XFeatureCall_4.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+		}
+		this_XLiteral_5=ruleXLiteral
+		{
+			$current = $this_XLiteral_5.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+		}
+		this_XIfExpression_6=ruleXIfExpression
+		{
+			$current = $this_XIfExpression_6.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		(
+			((
+				(
+				)
+				'for'
+				'('
+				(
+					(
+						ruleJvmFormalParameter
+					)
+				)
+				':'
+			)
+			)=>
+			{
+				newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+			}
+			this_XForLoopExpression_7=ruleXForLoopExpression
+			{
+				$current = $this_XForLoopExpression_7.current;
+				afterParserOrEnumRuleCall();
+			}
+		)
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+		}
+		this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression
+		{
+			$current = $this_XBasicForLoopExpression_8.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+		}
+		this_XWhileExpression_9=ruleXWhileExpression
+		{
+			$current = $this_XWhileExpression_9.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+		}
+		this_XDoWhileExpression_10=ruleXDoWhileExpression
+		{
+			$current = $this_XDoWhileExpression_10.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+		}
+		this_XThrowExpression_11=ruleXThrowExpression
+		{
+			$current = $this_XThrowExpression_11.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+		}
+		this_XReturnExpression_12=ruleXReturnExpression
+		{
+			$current = $this_XReturnExpression_12.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+		}
+		this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression
+		{
+			$current = $this_XTryCatchFinallyExpression_13.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+		}
+		this_XParenthesizedExpression_14=ruleXParenthesizedExpression
+		{
+			$current = $this_XParenthesizedExpression_14.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleXLiteral
+entryRuleXLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXLiteralRule()); }
+	iv_ruleXLiteral=ruleXLiteral
+	{ $current=$iv_ruleXLiteral.current; }
+	EOF;
+
+// Rule XLiteral
+ruleXLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+		}
+		this_XCollectionLiteral_0=ruleXCollectionLiteral
+		{
+			$current = $this_XCollectionLiteral_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		(
+			((
+				(
+				)
+				'['
+			)
+			)=>
+			{
+				newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+			}
+			this_XClosure_1=ruleXClosure
+			{
+				$current = $this_XClosure_1.current;
+				afterParserOrEnumRuleCall();
+			}
+		)
+		    |
+		{
+			newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+		}
+		this_XBooleanLiteral_2=ruleXBooleanLiteral
+		{
+			$current = $this_XBooleanLiteral_2.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+		}
+		this_XNumberLiteral_3=ruleXNumberLiteral
+		{
+			$current = $this_XNumberLiteral_3.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+		}
+		this_XNullLiteral_4=ruleXNullLiteral
+		{
+			$current = $this_XNullLiteral_4.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+		}
+		this_XStringLiteral_5=ruleXStringLiteral
+		{
+			$current = $this_XStringLiteral_5.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+		}
+		this_XTypeLiteral_6=ruleXTypeLiteral
+		{
+			$current = $this_XTypeLiteral_6.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleXCollectionLiteral
+entryRuleXCollectionLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXCollectionLiteralRule()); }
+	iv_ruleXCollectionLiteral=ruleXCollectionLiteral
+	{ $current=$iv_ruleXCollectionLiteral.current; }
+	EOF;
+
+// Rule XCollectionLiteral
+ruleXCollectionLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+		}
+		this_XSetLiteral_0=ruleXSetLiteral
+		{
+			$current = $this_XSetLiteral_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+		}
+		this_XListLiteral_1=ruleXListLiteral
+		{
+			$current = $this_XListLiteral_1.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleXSetLiteral
+entryRuleXSetLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXSetLiteralRule()); }
+	iv_ruleXSetLiteral=ruleXSetLiteral
+	{ $current=$iv_ruleXSetLiteral.current; }
+	EOF;
+
+// Rule XSetLiteral
+ruleXSetLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='#'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+		}
+		otherlv_2='{'
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+		}
+		(
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+					}
+					lv_elements_3_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+						}
+						add(
+							$current,
+							"elements",
+							lv_elements_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_4=','
+				{
+					newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+						}
+						lv_elements_5_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+							}
+							add(
+								$current,
+								"elements",
+								lv_elements_5_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+		)?
+		otherlv_6='}'
+		{
+			newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+		}
+	)
+;
+
+// Entry rule entryRuleXListLiteral
+entryRuleXListLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXListLiteralRule()); }
+	iv_ruleXListLiteral=ruleXListLiteral
+	{ $current=$iv_ruleXListLiteral.current; }
+	EOF;
+
+// Rule XListLiteral
+ruleXListLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='#'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+		}
+		otherlv_2='['
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+		}
+		(
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+					}
+					lv_elements_3_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+						}
+						add(
+							$current,
+							"elements",
+							lv_elements_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_4=','
+				{
+					newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+						}
+						lv_elements_5_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+							}
+							add(
+								$current,
+								"elements",
+								lv_elements_5_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+		)?
+		otherlv_6=']'
+		{
+			newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+		}
+	)
+;
+
+// Entry rule entryRuleXClosure
+entryRuleXClosure returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXClosureRule()); }
+	iv_ruleXClosure=ruleXClosure
+	{ $current=$iv_ruleXClosure.current; }
+	EOF;
+
+// Rule XClosure
+ruleXClosure returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			((
+				(
+				)
+				'['
+			)
+			)=>
+			(
+				(
+					{
+						$current = forceCreateModelElement(
+							grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(),
+							$current);
+					}
+				)
+				otherlv_1='['
+				{
+					newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+				}
+			)
+		)
+		(
+			((
+				(
+					(
+						(
+							ruleJvmFormalParameter
+						)
+					)
+					(
+						','
+						(
+							(
+								ruleJvmFormalParameter
+							)
+						)
+					)*
+				)?
+				(
+					(
+						'|'
+					)
+				)
+			)
+			)=>
+			(
+				(
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+							}
+							lv_declaredFormalParameters_2_0=ruleJvmFormalParameter
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXClosureRule());
+								}
+								add(
+									$current,
+									"declaredFormalParameters",
+									lv_declaredFormalParameters_2_0,
+									"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_3=','
+						{
+							newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+								}
+								lv_declaredFormalParameters_4_0=ruleJvmFormalParameter
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXClosureRule());
+									}
+									add(
+										$current,
+										"declaredFormalParameters",
+										lv_declaredFormalParameters_4_0,
+										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+				)?
+				(
+					(
+						lv_explicitSyntax_5_0='|'
+						{
+							newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+						}
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXClosureRule());
+							}
+							setWithLastConsumed($current, "explicitSyntax", true, "|");
+						}
+					)
+				)
+			)
+		)?
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+				}
+				lv_expression_6_0=ruleXExpressionInClosure
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXClosureRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_6_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpressionInClosure");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_7=']'
+		{
+			newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+		}
+	)
+;
+
+// Entry rule entryRuleXExpressionInClosure
+entryRuleXExpressionInClosure returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXExpressionInClosureRule()); }
+	iv_ruleXExpressionInClosure=ruleXExpressionInClosure
+	{ $current=$iv_ruleXExpressionInClosure.current; }
+	EOF;
+
+// Rule XExpressionInClosure
+ruleXExpressionInClosure returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(),
+					$current);
+			}
+		)
+		(
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+					}
+					lv_expressions_1_0=ruleXExpressionOrVarDeclaration
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule());
+						}
+						add(
+							$current,
+							"expressions",
+							lv_expressions_1_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_2=';'
+				{
+					newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+				}
+			)?
+		)*
+	)
+;
+
+// Entry rule entryRuleXShortClosure
+entryRuleXShortClosure returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXShortClosureRule()); }
+	iv_ruleXShortClosure=ruleXShortClosure
+	{ $current=$iv_ruleXShortClosure.current; }
+	EOF;
+
+// Rule XShortClosure
+ruleXShortClosure returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			((
+				(
+				)
+				(
+					(
+						(
+							ruleJvmFormalParameter
+						)
+					)
+					(
+						','
+						(
+							(
+								ruleJvmFormalParameter
+							)
+						)
+					)*
+				)?
+				(
+					(
+						'|'
+					)
+				)
+			)
+			)=>
+			(
+				(
+					{
+						$current = forceCreateModelElement(
+							grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(),
+							$current);
+					}
+				)
+				(
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+							}
+							lv_declaredFormalParameters_1_0=ruleJvmFormalParameter
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+								}
+								add(
+									$current,
+									"declaredFormalParameters",
+									lv_declaredFormalParameters_1_0,
+									"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_2=','
+						{
+							newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+								}
+								lv_declaredFormalParameters_3_0=ruleJvmFormalParameter
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+									}
+									add(
+										$current,
+										"declaredFormalParameters",
+										lv_declaredFormalParameters_3_0,
+										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+				)?
+				(
+					(
+						lv_explicitSyntax_4_0='|'
+						{
+							newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+						}
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getXShortClosureRule());
+							}
+							setWithLastConsumed($current, "explicitSyntax", true, "|");
+						}
+					)
+				)
+			)
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+				}
+				lv_expression_5_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_5_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXParenthesizedExpression
+entryRuleXParenthesizedExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); }
+	iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression
+	{ $current=$iv_ruleXParenthesizedExpression.current; }
+	EOF;
+
+// Rule XParenthesizedExpression
+ruleXParenthesizedExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		otherlv_0='('
+		{
+			newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+		}
+		{
+			newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+		}
+		this_XExpression_1=ruleXExpression
+		{
+			$current = $this_XExpression_1.current;
+			afterParserOrEnumRuleCall();
+		}
+		otherlv_2=')'
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+		}
+	)
+;
+
+// Entry rule entryRuleXIfExpression
+entryRuleXIfExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXIfExpressionRule()); }
+	iv_ruleXIfExpression=ruleXIfExpression
+	{ $current=$iv_ruleXIfExpression.current; }
+	EOF;
+
+// Rule XIfExpression
+ruleXIfExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='if'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+		}
+		otherlv_2='('
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+				}
+				lv_if_3_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+					}
+					set(
+						$current,
+						"if",
+						lv_if_3_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_4=')'
+		{
+			newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+				}
+				lv_then_5_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+					}
+					set(
+						$current,
+						"then",
+						lv_then_5_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				('else')=>
+				otherlv_6='else'
+				{
+					newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+				}
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+					}
+					lv_else_7_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+						}
+						set(
+							$current,
+							"else",
+							lv_else_7_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleXSwitchExpression
+entryRuleXSwitchExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXSwitchExpressionRule()); }
+	iv_ruleXSwitchExpression=ruleXSwitchExpression
+	{ $current=$iv_ruleXSwitchExpression.current; }
+	EOF;
+
+// Rule XSwitchExpression
+ruleXSwitchExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='switch'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+		}
+		(
+			(
+				(
+					((
+						'('
+						(
+							(
+								ruleJvmFormalParameter
+							)
+						)
+						':'
+					)
+					)=>
+					(
+						otherlv_2='('
+						{
+							newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+								}
+								lv_declaredParam_3_0=ruleJvmFormalParameter
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+									}
+									set(
+										$current,
+										"declaredParam",
+										lv_declaredParam_3_0,
+										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+						otherlv_4=':'
+						{
+							newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+						}
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+						}
+						lv_switch_5_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+							}
+							set(
+								$current,
+								"switch",
+								lv_switch_5_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				otherlv_6=')'
+				{
+					newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+				}
+			)
+			    |
+			(
+				(
+					((
+						(
+							(
+								ruleJvmFormalParameter
+							)
+						)
+						':'
+					)
+					)=>
+					(
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+								}
+								lv_declaredParam_7_0=ruleJvmFormalParameter
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+									}
+									set(
+										$current,
+										"declaredParam",
+										lv_declaredParam_7_0,
+										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+						otherlv_8=':'
+						{
+							newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+						}
+					)
+				)?
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+						}
+						lv_switch_9_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+							}
+							set(
+								$current,
+								"switch",
+								lv_switch_9_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+		)
+		otherlv_10='{'
+		{
+			newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+				}
+				lv_cases_11_0=ruleXCasePart
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+					}
+					add(
+						$current,
+						"cases",
+						lv_cases_11_0,
+						"org.eclipse.xtext.xbase.Xbase.XCasePart");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)*
+		(
+			otherlv_12='default'
+			{
+				newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+			}
+			otherlv_13=':'
+			{
+				newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+			}
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+					}
+					lv_default_14_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+						}
+						set(
+							$current,
+							"default",
+							lv_default_14_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)?
+		otherlv_15='}'
+		{
+			newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+		}
+	)
+;
+
+// Entry rule entryRuleXCasePart
+entryRuleXCasePart returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXCasePartRule()); }
+	iv_ruleXCasePart=ruleXCasePart
+	{ $current=$iv_ruleXCasePart.current; }
+	EOF;
+
+// Rule XCasePart
+ruleXCasePart returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXCasePartAccess().getXCasePartAction_0(),
+					$current);
+			}
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+				}
+				lv_typeGuard_1_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXCasePartRule());
+					}
+					set(
+						$current,
+						"typeGuard",
+						lv_typeGuard_1_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)?
+		(
+			otherlv_2='case'
+			{
+				newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+			}
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+					}
+					lv_case_3_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXCasePartRule());
+						}
+						set(
+							$current,
+							"case",
+							lv_case_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)?
+		(
+			(
+				otherlv_4=':'
+				{
+					newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+						}
+						lv_then_5_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXCasePartRule());
+							}
+							set(
+								$current,
+								"then",
+								lv_then_5_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+			    |
+			(
+				(
+					lv_fallThrough_6_0=','
+					{
+						newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+					}
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXCasePartRule());
+						}
+						setWithLastConsumed($current, "fallThrough", true, ",");
+					}
+				)
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXForLoopExpression
+entryRuleXForLoopExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXForLoopExpressionRule()); }
+	iv_ruleXForLoopExpression=ruleXForLoopExpression
+	{ $current=$iv_ruleXForLoopExpression.current; }
+	EOF;
+
+// Rule XForLoopExpression
+ruleXForLoopExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			((
+				(
+				)
+				'for'
+				'('
+				(
+					(
+						ruleJvmFormalParameter
+					)
+				)
+				':'
+			)
+			)=>
+			(
+				(
+					{
+						$current = forceCreateModelElement(
+							grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(),
+							$current);
+					}
+				)
+				otherlv_1='for'
+				{
+					newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+				}
+				otherlv_2='('
+				{
+					newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+						}
+						lv_declaredParam_3_0=ruleJvmFormalParameter
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+							}
+							set(
+								$current,
+								"declaredParam",
+								lv_declaredParam_3_0,
+								"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				otherlv_4=':'
+				{
+					newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+				}
+			)
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+				}
+				lv_forExpression_5_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+					}
+					set(
+						$current,
+						"forExpression",
+						lv_forExpression_5_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_6=')'
+		{
+			newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+				}
+				lv_eachExpression_7_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+					}
+					set(
+						$current,
+						"eachExpression",
+						lv_eachExpression_7_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXBasicForLoopExpression
+entryRuleXBasicForLoopExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); }
+	iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression
+	{ $current=$iv_ruleXBasicForLoopExpression.current; }
+	EOF;
+
+// Rule XBasicForLoopExpression
+ruleXBasicForLoopExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='for'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+		}
+		otherlv_2='('
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+		}
+		(
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+					}
+					lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+						}
+						add(
+							$current,
+							"initExpressions",
+							lv_initExpressions_3_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_4=','
+				{
+					newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+						}
+						lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+							}
+							add(
+								$current,
+								"initExpressions",
+								lv_initExpressions_5_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+		)?
+		otherlv_6=';'
+		{
+			newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+				}
+				lv_expression_7_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_7_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)?
+		otherlv_8=';'
+		{
+			newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+		}
+		(
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+					}
+					lv_updateExpressions_9_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+						}
+						add(
+							$current,
+							"updateExpressions",
+							lv_updateExpressions_9_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_10=','
+				{
+					newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+						}
+						lv_updateExpressions_11_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+							}
+							add(
+								$current,
+								"updateExpressions",
+								lv_updateExpressions_11_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+		)?
+		otherlv_12=')'
+		{
+			newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+				}
+				lv_eachExpression_13_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+					}
+					set(
+						$current,
+						"eachExpression",
+						lv_eachExpression_13_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXWhileExpression
+entryRuleXWhileExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXWhileExpressionRule()); }
+	iv_ruleXWhileExpression=ruleXWhileExpression
+	{ $current=$iv_ruleXWhileExpression.current; }
+	EOF;
+
+// Rule XWhileExpression
+ruleXWhileExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='while'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+		}
+		otherlv_2='('
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+				}
+				lv_predicate_3_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+					}
+					set(
+						$current,
+						"predicate",
+						lv_predicate_3_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_4=')'
+		{
+			newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+				}
+				lv_body_5_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+					}
+					set(
+						$current,
+						"body",
+						lv_body_5_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXDoWhileExpression
+entryRuleXDoWhileExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); }
+	iv_ruleXDoWhileExpression=ruleXDoWhileExpression
+	{ $current=$iv_ruleXDoWhileExpression.current; }
+	EOF;
+
+// Rule XDoWhileExpression
+ruleXDoWhileExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='do'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+				}
+				lv_body_2_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+					}
+					set(
+						$current,
+						"body",
+						lv_body_2_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_3='while'
+		{
+			newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+		}
+		otherlv_4='('
+		{
+			newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+				}
+				lv_predicate_5_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+					}
+					set(
+						$current,
+						"predicate",
+						lv_predicate_5_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_6=')'
+		{
+			newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+		}
+	)
+;
+
+// Entry rule entryRuleXBlockExpression
+entryRuleXBlockExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXBlockExpressionRule()); }
+	iv_ruleXBlockExpression=ruleXBlockExpression
+	{ $current=$iv_ruleXBlockExpression.current; }
+	EOF;
+
+// Rule XBlockExpression
+ruleXBlockExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='{'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+		}
+		(
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+					}
+					lv_expressions_2_0=ruleXExpressionOrVarDeclaration
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXBlockExpressionRule());
+						}
+						add(
+							$current,
+							"expressions",
+							lv_expressions_2_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_3=';'
+				{
+					newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+				}
+			)?
+		)*
+		otherlv_4='}'
+		{
+			newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+		}
+	)
+;
+
+// Entry rule entryRuleXExpressionOrVarDeclaration
+entryRuleXExpressionOrVarDeclaration returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); }
+	iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration
+	{ $current=$iv_ruleXExpressionOrVarDeclaration.current; }
+	EOF;
+
+// Rule XExpressionOrVarDeclaration
+ruleXExpressionOrVarDeclaration returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+		}
+		this_XVariableDeclaration_0=ruleXVariableDeclaration
+		{
+			$current = $this_XVariableDeclaration_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+		}
+		this_XExpression_1=ruleXExpression
+		{
+			$current = $this_XExpression_1.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleXVariableDeclaration
+entryRuleXVariableDeclaration returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXVariableDeclarationRule()); }
+	iv_ruleXVariableDeclaration=ruleXVariableDeclaration
+	{ $current=$iv_ruleXVariableDeclaration.current; }
+	EOF;
+
+// Rule XVariableDeclaration
+ruleXVariableDeclaration returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(),
+					$current);
+			}
+		)
+		(
+			(
+				(
+					lv_writeable_1_0='var'
+					{
+						newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+					}
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXVariableDeclarationRule());
+						}
+						setWithLastConsumed($current, "writeable", true, "var");
+					}
+				)
+			)
+			    |
+			otherlv_2='val'
+			{
+				newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+			}
+		)
+		(
+			(
+				((
+					(
+						(
+							ruleJvmTypeReference
+						)
+					)
+					(
+						(
+							ruleValidID
+						)
+					)
+				)
+				)=>
+				(
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+							}
+							lv_type_3_0=ruleJvmTypeReference
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+								}
+								set(
+									$current,
+									"type",
+									lv_type_3_0,
+									"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+							}
+							lv_name_4_0=ruleValidID
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+								}
+								set(
+									$current,
+									"name",
+									lv_name_4_0,
+									"org.eclipse.xtext.xbase.Xtype.ValidID");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)
+			)
+			    |
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+					}
+					lv_name_5_0=ruleValidID
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+						}
+						set(
+							$current,
+							"name",
+							lv_name_5_0,
+							"org.eclipse.xtext.xbase.Xtype.ValidID");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)
+		(
+			otherlv_6='='
+			{
+				newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+			}
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+					}
+					lv_right_7_0=ruleXExpression
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+						}
+						set(
+							$current,
+							"right",
+							lv_right_7_0,
+							"org.eclipse.xtext.xbase.Xbase.XExpression");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleJvmFormalParameter
+entryRuleJvmFormalParameter returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmFormalParameterRule()); }
+	iv_ruleJvmFormalParameter=ruleJvmFormalParameter
+	{ $current=$iv_ruleJvmFormalParameter.current; }
+	EOF;
+
+// Rule JvmFormalParameter
+ruleJvmFormalParameter returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+				}
+				lv_parameterType_0_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+					}
+					set(
+						$current,
+						"parameterType",
+						lv_parameterType_0_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)?
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+				}
+				lv_name_1_0=ruleValidID
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+					}
+					set(
+						$current,
+						"name",
+						lv_name_1_0,
+						"org.eclipse.xtext.xbase.Xtype.ValidID");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleFullJvmFormalParameter
+entryRuleFullJvmFormalParameter returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); }
+	iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter
+	{ $current=$iv_ruleFullJvmFormalParameter.current; }
+	EOF;
+
+// Rule FullJvmFormalParameter
+ruleFullJvmFormalParameter returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+				}
+				lv_parameterType_0_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+					}
+					set(
+						$current,
+						"parameterType",
+						lv_parameterType_0_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+				}
+				lv_name_1_0=ruleValidID
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+					}
+					set(
+						$current,
+						"name",
+						lv_name_1_0,
+						"org.eclipse.xtext.xbase.Xtype.ValidID");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXFeatureCall
+entryRuleXFeatureCall returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXFeatureCallRule()); }
+	iv_ruleXFeatureCall=ruleXFeatureCall
+	{ $current=$iv_ruleXFeatureCall.current; }
+	EOF;
+
+// Rule XFeatureCall
+ruleXFeatureCall returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(),
+					$current);
+			}
+		)
+		(
+			otherlv_1='<'
+			{
+				newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+			}
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+					}
+					lv_typeArguments_2_0=ruleJvmArgumentTypeReference
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+						}
+						add(
+							$current,
+							"typeArguments",
+							lv_typeArguments_2_0,
+							"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_3=','
+				{
+					newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+						}
+						lv_typeArguments_4_0=ruleJvmArgumentTypeReference
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+							}
+							add(
+								$current,
+								"typeArguments",
+								lv_typeArguments_4_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+			otherlv_5='>'
+			{
+				newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+			}
+		)?
+		(
+			(
+				{
+					if ($current==null) {
+						$current = createModelElement(grammarAccess.getXFeatureCallRule());
+					}
+				}
+				{
+					newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+				}
+				ruleIdOrSuper
+				{
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				((
+					'('
+				)
+				)=>
+				(
+					lv_explicitOperationCall_7_0='('
+					{
+						newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+					}
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXFeatureCallRule());
+						}
+						setWithLastConsumed($current, "explicitOperationCall", true, "(");
+					}
+				)
+			)
+			(
+				(
+					((
+						(
+						)
+						(
+							(
+								(
+									ruleJvmFormalParameter
+								)
+							)
+							(
+								','
+								(
+									(
+										ruleJvmFormalParameter
+									)
+								)
+							)*
+						)?
+						(
+							(
+								'|'
+							)
+						)
+					)
+					)=>
+					(
+						{
+							newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+						}
+						lv_featureCallArguments_8_0=ruleXShortClosure
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+							}
+							add(
+								$current,
+								"featureCallArguments",
+								lv_featureCallArguments_8_0,
+								"org.eclipse.xtext.xbase.Xbase.XShortClosure");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				    |
+				(
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+							}
+							lv_featureCallArguments_9_0=ruleXExpression
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+								}
+								add(
+									$current,
+									"featureCallArguments",
+									lv_featureCallArguments_9_0,
+									"org.eclipse.xtext.xbase.Xbase.XExpression");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_10=','
+						{
+							newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+								}
+								lv_featureCallArguments_11_0=ruleXExpression
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+									}
+									add(
+										$current,
+										"featureCallArguments",
+										lv_featureCallArguments_11_0,
+										"org.eclipse.xtext.xbase.Xbase.XExpression");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+				)
+			)?
+			otherlv_12=')'
+			{
+				newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+			}
+		)?
+		(
+			((
+				(
+				)
+				'['
+			)
+			)=>
+			(
+				{
+					newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+				}
+				lv_featureCallArguments_13_0=ruleXClosure
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+					}
+					add(
+						$current,
+						"featureCallArguments",
+						lv_featureCallArguments_13_0,
+						"org.eclipse.xtext.xbase.Xbase.XClosure");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleFeatureCallID
+entryRuleFeatureCallID returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getFeatureCallIDRule()); }
+	iv_ruleFeatureCallID=ruleFeatureCallID
+	{ $current=$iv_ruleFeatureCallID.current.getText(); }
+	EOF;
+
+// Rule FeatureCallID
+ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+		}
+		this_ValidID_0=ruleValidID
+		{
+			$current.merge(this_ValidID_0);
+		}
+		{
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		kw='extends'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+		}
+		    |
+		kw='static'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+		}
+		    |
+		kw='import'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+		}
+		    |
+		kw='extension'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+		}
+	)
+;
+
+// Entry rule entryRuleIdOrSuper
+entryRuleIdOrSuper returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getIdOrSuperRule()); }
+	iv_ruleIdOrSuper=ruleIdOrSuper
+	{ $current=$iv_ruleIdOrSuper.current.getText(); }
+	EOF;
+
+// Rule IdOrSuper
+ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+		}
+		this_FeatureCallID_0=ruleFeatureCallID
+		{
+			$current.merge(this_FeatureCallID_0);
+		}
+		{
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		kw='super'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+		}
+	)
+;
+
+// Entry rule entryRuleXConstructorCall
+entryRuleXConstructorCall returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXConstructorCallRule()); }
+	iv_ruleXConstructorCall=ruleXConstructorCall
+	{ $current=$iv_ruleXConstructorCall.current; }
+	EOF;
+
+// Rule XConstructorCall
+ruleXConstructorCall returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='new'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+		}
+		(
+			(
+				{
+					if ($current==null) {
+						$current = createModelElement(grammarAccess.getXConstructorCallRule());
+					}
+				}
+				{
+					newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+				}
+				ruleQualifiedName
+				{
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				('<')=>
+				otherlv_3='<'
+				{
+					newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+				}
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+					}
+					lv_typeArguments_4_0=ruleJvmArgumentTypeReference
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+						}
+						add(
+							$current,
+							"typeArguments",
+							lv_typeArguments_4_0,
+							"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_5=','
+				{
+					newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+						}
+						lv_typeArguments_6_0=ruleJvmArgumentTypeReference
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+							}
+							add(
+								$current,
+								"typeArguments",
+								lv_typeArguments_6_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+			otherlv_7='>'
+			{
+				newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+			}
+		)?
+		(
+			(
+				((
+					'('
+				)
+				)=>
+				(
+					lv_explicitConstructorCall_8_0='('
+					{
+						newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+					}
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXConstructorCallRule());
+						}
+						setWithLastConsumed($current, "explicitConstructorCall", true, "(");
+					}
+				)
+			)
+			(
+				(
+					((
+						(
+						)
+						(
+							(
+								(
+									ruleJvmFormalParameter
+								)
+							)
+							(
+								','
+								(
+									(
+										ruleJvmFormalParameter
+									)
+								)
+							)*
+						)?
+						(
+							(
+								'|'
+							)
+						)
+					)
+					)=>
+					(
+						{
+							newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+						}
+						lv_arguments_9_0=ruleXShortClosure
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+							}
+							add(
+								$current,
+								"arguments",
+								lv_arguments_9_0,
+								"org.eclipse.xtext.xbase.Xbase.XShortClosure");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				    |
+				(
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+							}
+							lv_arguments_10_0=ruleXExpression
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+								}
+								add(
+									$current,
+									"arguments",
+									lv_arguments_10_0,
+									"org.eclipse.xtext.xbase.Xbase.XExpression");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_11=','
+						{
+							newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+								}
+								lv_arguments_12_0=ruleXExpression
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+									}
+									add(
+										$current,
+										"arguments",
+										lv_arguments_12_0,
+										"org.eclipse.xtext.xbase.Xbase.XExpression");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+				)
+			)?
+			otherlv_13=')'
+			{
+				newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+			}
+		)?
+		(
+			((
+				(
+				)
+				'['
+			)
+			)=>
+			(
+				{
+					newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+				}
+				lv_arguments_14_0=ruleXClosure
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+					}
+					add(
+						$current,
+						"arguments",
+						lv_arguments_14_0,
+						"org.eclipse.xtext.xbase.Xbase.XClosure");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleXBooleanLiteral
+entryRuleXBooleanLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXBooleanLiteralRule()); }
+	iv_ruleXBooleanLiteral=ruleXBooleanLiteral
+	{ $current=$iv_ruleXBooleanLiteral.current; }
+	EOF;
+
+// Rule XBooleanLiteral
+ruleXBooleanLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(),
+					$current);
+			}
+		)
+		(
+			otherlv_1='false'
+			{
+				newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+			}
+			    |
+			(
+				(
+					lv_isTrue_2_0='true'
+					{
+						newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+					}
+					{
+						if ($current==null) {
+							$current = createModelElement(grammarAccess.getXBooleanLiteralRule());
+						}
+						setWithLastConsumed($current, "isTrue", true, "true");
+					}
+				)
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXNullLiteral
+entryRuleXNullLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXNullLiteralRule()); }
+	iv_ruleXNullLiteral=ruleXNullLiteral
+	{ $current=$iv_ruleXNullLiteral.current; }
+	EOF;
+
+// Rule XNullLiteral
+ruleXNullLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='null'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+		}
+	)
+;
+
+// Entry rule entryRuleXNumberLiteral
+entryRuleXNumberLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXNumberLiteralRule()); }
+	iv_ruleXNumberLiteral=ruleXNumberLiteral
+	{ $current=$iv_ruleXNumberLiteral.current; }
+	EOF;
+
+// Rule XNumberLiteral
+ruleXNumberLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(),
+					$current);
+			}
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+				}
+				lv_value_1_0=ruleNumber
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXNumberLiteralRule());
+					}
+					set(
+						$current,
+						"value",
+						lv_value_1_0,
+						"org.eclipse.xtext.xbase.Xbase.Number");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXStringLiteral
+entryRuleXStringLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXStringLiteralRule()); }
+	iv_ruleXStringLiteral=ruleXStringLiteral
+	{ $current=$iv_ruleXStringLiteral.current; }
+	EOF;
+
+// Rule XStringLiteral
+ruleXStringLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(),
+					$current);
+			}
+		)
+		(
+			(
+				lv_value_1_0=RULE_STRING
+				{
+					newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0());
+				}
+				{
+					if ($current==null) {
+						$current = createModelElement(grammarAccess.getXStringLiteralRule());
+					}
+					setWithLastConsumed(
+						$current,
+						"value",
+						lv_value_1_0,
+						"org.eclipse.xtext.xbase.Xtype.STRING");
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXTypeLiteral
+entryRuleXTypeLiteral returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXTypeLiteralRule()); }
+	iv_ruleXTypeLiteral=ruleXTypeLiteral
+	{ $current=$iv_ruleXTypeLiteral.current; }
+	EOF;
+
+// Rule XTypeLiteral
+ruleXTypeLiteral returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='typeof'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1());
+		}
+		otherlv_2='('
+		{
+			newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2());
+		}
+		(
+			(
+				{
+					if ($current==null) {
+						$current = createModelElement(grammarAccess.getXTypeLiteralRule());
+					}
+				}
+				{
+					newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0());
+				}
+				ruleQualifiedName
+				{
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0());
+				}
+				lv_arrayDimensions_4_0=ruleArrayBrackets
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXTypeLiteralRule());
+					}
+					add(
+						$current,
+						"arrayDimensions",
+						lv_arrayDimensions_4_0,
+						"org.eclipse.xtext.xbase.Xtype.ArrayBrackets");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)*
+		otherlv_5=')'
+		{
+			newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5());
+		}
+	)
+;
+
+// Entry rule entryRuleXThrowExpression
+entryRuleXThrowExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXThrowExpressionRule()); }
+	iv_ruleXThrowExpression=ruleXThrowExpression
+	{ $current=$iv_ruleXThrowExpression.current; }
+	EOF;
+
+// Rule XThrowExpression
+ruleXThrowExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='throw'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+				}
+				lv_expression_2_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXThrowExpressionRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_2_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXReturnExpression
+entryRuleXReturnExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXReturnExpressionRule()); }
+	iv_ruleXReturnExpression=ruleXReturnExpression
+	{ $current=$iv_ruleXReturnExpression.current; }
+	EOF;
+
+// Rule XReturnExpression
+ruleXReturnExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='return'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1());
+		}
+		(
+			('extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING)=>
+			(
+				{
+					newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+				}
+				lv_expression_2_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXReturnExpressionRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_2_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleXTryCatchFinallyExpression
+entryRuleXTryCatchFinallyExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); }
+	iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression
+	{ $current=$iv_ruleXTryCatchFinallyExpression.current; }
+	EOF;
+
+// Rule XTryCatchFinallyExpression
+ruleXTryCatchFinallyExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='try'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+				}
+				lv_expression_2_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_2_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				(
+					('catch')=>
+					(
+						{
+							newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0());
+						}
+						lv_catchClauses_3_0=ruleXCatchClause
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+							}
+							add(
+								$current,
+								"catchClauses",
+								lv_catchClauses_3_0,
+								"org.eclipse.xtext.xbase.Xbase.XCatchClause");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)+
+				(
+					(
+						('finally')=>
+						otherlv_4='finally'
+						{
+							newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0());
+						}
+					)
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0());
+							}
+							lv_finallyExpression_5_0=ruleXExpression
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+								}
+								set(
+									$current,
+									"finallyExpression",
+									lv_finallyExpression_5_0,
+									"org.eclipse.xtext.xbase.Xbase.XExpression");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)?
+			)
+			    |
+			(
+				otherlv_6='finally'
+				{
+					newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0());
+						}
+						lv_finallyExpression_7_0=ruleXExpression
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+							}
+							set(
+								$current,
+								"finallyExpression",
+								lv_finallyExpression_7_0,
+								"org.eclipse.xtext.xbase.Xbase.XExpression");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXSynchronizedExpression
+entryRuleXSynchronizedExpression returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); }
+	iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression
+	{ $current=$iv_ruleXSynchronizedExpression.current; }
+	EOF;
+
+// Rule XSynchronizedExpression
+ruleXSynchronizedExpression returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			((
+				(
+				)
+				'synchronized'
+				'('
+			)
+			)=>
+			(
+				(
+					{
+						$current = forceCreateModelElement(
+							grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(),
+							$current);
+					}
+				)
+				otherlv_1='synchronized'
+				{
+					newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1());
+				}
+				otherlv_2='('
+				{
+					newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+				}
+			)
+		)
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0());
+				}
+				lv_param_3_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+					}
+					set(
+						$current,
+						"param",
+						lv_param_3_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_4=')'
+		{
+			newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0());
+				}
+				lv_expression_5_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_5_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleXCatchClause
+entryRuleXCatchClause returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXCatchClauseRule()); }
+	iv_ruleXCatchClause=ruleXCatchClause
+	{ $current=$iv_ruleXCatchClause.current; }
+	EOF;
+
+// Rule XCatchClause
+ruleXCatchClause returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			('catch')=>
+			otherlv_0='catch'
+			{
+				newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0());
+			}
+		)
+		otherlv_1='('
+		{
+			newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0());
+				}
+				lv_declaredParam_2_0=ruleFullJvmFormalParameter
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+					}
+					set(
+						$current,
+						"declaredParam",
+						lv_declaredParam_2_0,
+						"org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		otherlv_3=')'
+		{
+			newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0());
+				}
+				lv_expression_4_0=ruleXExpression
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+					}
+					set(
+						$current,
+						"expression",
+						lv_expression_4_0,
+						"org.eclipse.xtext.xbase.Xbase.XExpression");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleQualifiedName
+entryRuleQualifiedName returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getQualifiedNameRule()); }
+	iv_ruleQualifiedName=ruleQualifiedName
+	{ $current=$iv_ruleQualifiedName.current.getText(); }
+	EOF;
+
+// Rule QualifiedName
+ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+		}
+		this_ValidID_0=ruleValidID
+		{
+			$current.merge(this_ValidID_0);
+		}
+		{
+			afterParserOrEnumRuleCall();
+		}
+		(
+			(
+				('.')=>
+				kw='.'
+				{
+					$current.merge(kw);
+					newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+				}
+			)
+			{
+				newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+			}
+			this_ValidID_2=ruleValidID
+			{
+				$current.merge(this_ValidID_2);
+			}
+			{
+				afterParserOrEnumRuleCall();
+			}
+		)*
+	)
+;
+
+// Entry rule entryRuleNumber
+entryRuleNumber returns [String current=null]@init {
+	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}:
+	{ newCompositeNode(grammarAccess.getNumberRule()); }
+	iv_ruleNumber=ruleNumber
+	{ $current=$iv_ruleNumber.current.getText(); }
+	EOF;
+finally {
+	myHiddenTokenState.restore();
+}
+
+// Rule Number
+ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+}
+@after {
+	leaveRule();
+}:
+	(
+		this_HEX_0=RULE_HEX
+		{
+			$current.merge(this_HEX_0);
+		}
+		{
+			newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0());
+		}
+		    |
+		(
+			(
+				this_INT_1=RULE_INT
+				{
+					$current.merge(this_INT_1);
+				}
+				{
+					newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0());
+				}
+				    |
+				this_DECIMAL_2=RULE_DECIMAL
+				{
+					$current.merge(this_DECIMAL_2);
+				}
+				{
+					newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1());
+				}
+			)
+			(
+				kw='.'
+				{
+					$current.merge(kw);
+					newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0());
+				}
+				(
+					this_INT_4=RULE_INT
+					{
+						$current.merge(this_INT_4);
+					}
+					{
+						newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0());
+					}
+					    |
+					this_DECIMAL_5=RULE_DECIMAL
+					{
+						$current.merge(this_DECIMAL_5);
+					}
+					{
+						newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1());
+					}
+				)
+			)?
+		)
+	)
+;
+finally {
+	myHiddenTokenState.restore();
+}
+
+// Entry rule entryRuleJvmTypeReference
+entryRuleJvmTypeReference returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); }
+	iv_ruleJvmTypeReference=ruleJvmTypeReference
+	{ $current=$iv_ruleJvmTypeReference.current; }
+	EOF;
+
+// Rule JvmTypeReference
+ruleJvmTypeReference returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0());
+			}
+			this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference
+			{
+				$current = $this_JvmParameterizedTypeReference_0.current;
+				afterParserOrEnumRuleCall();
+			}
+			(
+				((
+					(
+					)
+					ruleArrayBrackets
+				)
+				)=>
+				(
+					(
+						{
+							$current = forceCreateModelElementAndSet(
+								grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(),
+								$current);
+						}
+					)
+					{
+						newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1());
+					}
+					ruleArrayBrackets
+					{
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)*
+		)
+		    |
+		{
+			newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1());
+		}
+		this_XFunctionTypeRef_3=ruleXFunctionTypeRef
+		{
+			$current = $this_XFunctionTypeRef_3.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleArrayBrackets
+entryRuleArrayBrackets returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getArrayBracketsRule()); }
+	iv_ruleArrayBrackets=ruleArrayBrackets
+	{ $current=$iv_ruleArrayBrackets.current.getText(); }
+	EOF;
+
+// Rule ArrayBrackets
+ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		kw='['
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0());
+		}
+		kw=']'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1());
+		}
+	)
+;
+
+// Entry rule entryRuleXFunctionTypeRef
+entryRuleXFunctionTypeRef returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); }
+	iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef
+	{ $current=$iv_ruleXFunctionTypeRef.current; }
+	EOF;
+
+// Rule XFunctionTypeRef
+ruleXFunctionTypeRef returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			otherlv_0='('
+			{
+				newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0());
+			}
+			(
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0());
+						}
+						lv_paramTypes_1_0=ruleJvmTypeReference
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+							}
+							add(
+								$current,
+								"paramTypes",
+								lv_paramTypes_1_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					otherlv_2=','
+					{
+						newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0());
+					}
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0());
+							}
+							lv_paramTypes_3_0=ruleJvmTypeReference
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+								}
+								add(
+									$current,
+									"paramTypes",
+									lv_paramTypes_3_0,
+									"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+				)*
+			)?
+			otherlv_4=')'
+			{
+				newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2());
+			}
+		)?
+		otherlv_5='=>'
+		{
+			newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0());
+				}
+				lv_returnType_6_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+					}
+					set(
+						$current,
+						"returnType",
+						lv_returnType_6_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleJvmParameterizedTypeReference
+entryRuleJvmParameterizedTypeReference returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
+	iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference
+	{ $current=$iv_ruleJvmParameterizedTypeReference.current; }
+	EOF;
+
+// Rule JvmParameterizedTypeReference
+ruleJvmParameterizedTypeReference returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			(
+				{
+					if ($current==null) {
+						$current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+					}
+				}
+				{
+					newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0());
+				}
+				ruleQualifiedName
+				{
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+		(
+			(
+				('<')=>
+				otherlv_1='<'
+				{
+					newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0());
+				}
+			)
+			(
+				(
+					{
+						newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+					}
+					lv_arguments_2_0=ruleJvmArgumentTypeReference
+					{
+						if ($current==null) {
+							$current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+						}
+						add(
+							$current,
+							"arguments",
+							lv_arguments_2_0,
+							"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+						afterParserOrEnumRuleCall();
+					}
+				)
+			)
+			(
+				otherlv_3=','
+				{
+					newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0());
+				}
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+						}
+						lv_arguments_4_0=ruleJvmArgumentTypeReference
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+							}
+							add(
+								$current,
+								"arguments",
+								lv_arguments_4_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+			)*
+			otherlv_5='>'
+			{
+				newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3());
+			}
+			(
+				(
+					((
+						(
+						)
+						'.'
+					)
+					)=>
+					(
+						(
+							{
+								$current = forceCreateModelElementAndSet(
+									grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(),
+									$current);
+							}
+						)
+						otherlv_7='.'
+						{
+							newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1());
+						}
+					)
+				)
+				(
+					(
+						{
+							if ($current==null) {
+								$current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+							}
+						}
+						{
+							newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0());
+						}
+						ruleValidID
+						{
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					(
+						('<')=>
+						otherlv_9='<'
+						{
+							newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0());
+						}
+					)
+					(
+						(
+							{
+								newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0());
+							}
+							lv_arguments_10_0=ruleJvmArgumentTypeReference
+							{
+								if ($current==null) {
+									$current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+								}
+								add(
+									$current,
+									"arguments",
+									lv_arguments_10_0,
+									"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+								afterParserOrEnumRuleCall();
+							}
+						)
+					)
+					(
+						otherlv_11=','
+						{
+							newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0());
+						}
+						(
+							(
+								{
+									newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0());
+								}
+								lv_arguments_12_0=ruleJvmArgumentTypeReference
+								{
+									if ($current==null) {
+										$current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+									}
+									add(
+										$current,
+										"arguments",
+										lv_arguments_12_0,
+										"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+									afterParserOrEnumRuleCall();
+								}
+							)
+						)
+					)*
+					otherlv_13='>'
+					{
+						newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3());
+					}
+				)?
+			)*
+		)?
+	)
+;
+
+// Entry rule entryRuleJvmArgumentTypeReference
+entryRuleJvmArgumentTypeReference returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); }
+	iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference
+	{ $current=$iv_ruleJvmArgumentTypeReference.current; }
+	EOF;
+
+// Rule JvmArgumentTypeReference
+ruleJvmArgumentTypeReference returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0());
+		}
+		this_JvmTypeReference_0=ruleJvmTypeReference
+		{
+			$current = $this_JvmTypeReference_0.current;
+			afterParserOrEnumRuleCall();
+		}
+		    |
+		{
+			newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1());
+		}
+		this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference
+		{
+			$current = $this_JvmWildcardTypeReference_1.current;
+			afterParserOrEnumRuleCall();
+		}
+	)
+;
+
+// Entry rule entryRuleJvmWildcardTypeReference
+entryRuleJvmWildcardTypeReference returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); }
+	iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference
+	{ $current=$iv_ruleJvmWildcardTypeReference.current; }
+	EOF;
+
+// Rule JvmWildcardTypeReference
+ruleJvmWildcardTypeReference returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		(
+			{
+				$current = forceCreateModelElement(
+					grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(),
+					$current);
+			}
+		)
+		otherlv_1='?'
+		{
+			newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1());
+		}
+		(
+			(
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0());
+						}
+						lv_constraints_2_0=ruleJvmUpperBound
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+							}
+							add(
+								$current,
+								"constraints",
+								lv_constraints_2_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmUpperBound");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0());
+						}
+						lv_constraints_3_0=ruleJvmUpperBoundAnded
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+							}
+							add(
+								$current,
+								"constraints",
+								lv_constraints_3_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)*
+			)
+			    |
+			(
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0());
+						}
+						lv_constraints_4_0=ruleJvmLowerBound
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+							}
+							add(
+								$current,
+								"constraints",
+								lv_constraints_4_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmLowerBound");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)
+				(
+					(
+						{
+							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0());
+						}
+						lv_constraints_5_0=ruleJvmLowerBoundAnded
+						{
+							if ($current==null) {
+								$current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+							}
+							add(
+								$current,
+								"constraints",
+								lv_constraints_5_0,
+								"org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded");
+							afterParserOrEnumRuleCall();
+						}
+					)
+				)*
+			)
+		)?
+	)
+;
+
+// Entry rule entryRuleJvmUpperBound
+entryRuleJvmUpperBound returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmUpperBoundRule()); }
+	iv_ruleJvmUpperBound=ruleJvmUpperBound
+	{ $current=$iv_ruleJvmUpperBound.current; }
+	EOF;
+
+// Rule JvmUpperBound
+ruleJvmUpperBound returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		otherlv_0='extends'
+		{
+			newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+				}
+				lv_typeReference_1_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule());
+					}
+					set(
+						$current,
+						"typeReference",
+						lv_typeReference_1_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleJvmUpperBoundAnded
+entryRuleJvmUpperBoundAnded returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); }
+	iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded
+	{ $current=$iv_ruleJvmUpperBoundAnded.current; }
+	EOF;
+
+// Rule JvmUpperBoundAnded
+ruleJvmUpperBoundAnded returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		otherlv_0='&'
+		{
+			newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+				}
+				lv_typeReference_1_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule());
+					}
+					set(
+						$current,
+						"typeReference",
+						lv_typeReference_1_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleJvmLowerBound
+entryRuleJvmLowerBound returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmLowerBoundRule()); }
+	iv_ruleJvmLowerBound=ruleJvmLowerBound
+	{ $current=$iv_ruleJvmLowerBound.current; }
+	EOF;
+
+// Rule JvmLowerBound
+ruleJvmLowerBound returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		otherlv_0='super'
+		{
+			newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+				}
+				lv_typeReference_1_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule());
+					}
+					set(
+						$current,
+						"typeReference",
+						lv_typeReference_1_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleJvmLowerBoundAnded
+entryRuleJvmLowerBoundAnded returns [EObject current=null]:
+	{ newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); }
+	iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded
+	{ $current=$iv_ruleJvmLowerBoundAnded.current; }
+	EOF;
+
+// Rule JvmLowerBoundAnded
+ruleJvmLowerBoundAnded returns [EObject current=null]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		otherlv_0='&'
+		{
+			newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0());
+		}
+		(
+			(
+				{
+					newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+				}
+				lv_typeReference_1_0=ruleJvmTypeReference
+				{
+					if ($current==null) {
+						$current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule());
+					}
+					set(
+						$current,
+						"typeReference",
+						lv_typeReference_1_0,
+						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+					afterParserOrEnumRuleCall();
+				}
+			)
+		)
+	)
+;
+
+// Entry rule entryRuleQualifiedNameWithWildcard
+entryRuleQualifiedNameWithWildcard returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); }
+	iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard
+	{ $current=$iv_ruleQualifiedNameWithWildcard.current.getText(); }
+	EOF;
+
+// Rule QualifiedNameWithWildcard
+ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0());
+		}
+		this_QualifiedName_0=ruleQualifiedName
+		{
+			$current.merge(this_QualifiedName_0);
+		}
+		{
+			afterParserOrEnumRuleCall();
+		}
+		kw='.'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1());
+		}
+		kw='*'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2());
+		}
+	)
+;
+
+// Entry rule entryRuleValidID
+entryRuleValidID returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getValidIDRule()); }
+	iv_ruleValidID=ruleValidID
+	{ $current=$iv_ruleValidID.current.getText(); }
+	EOF;
+
+// Rule ValidID
+ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	this_ID_0=RULE_ID
+	{
+		$current.merge(this_ID_0);
+	}
+	{
+		newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+	}
+;
+
+// Entry rule entryRuleQualifiedNameInStaticImport
+entryRuleQualifiedNameInStaticImport returns [String current=null]:
+	{ newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); }
+	iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport
+	{ $current=$iv_ruleQualifiedNameInStaticImport.current.getText(); }
+	EOF;
+
+// Rule QualifiedNameInStaticImport
+ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()]
+@init {
+	enterRule();
+}
+@after {
+	leaveRule();
+}:
+	(
+		{
+			newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0());
+		}
+		this_ValidID_0=ruleValidID
+		{
+			$current.merge(this_ValidID_0);
+		}
+		{
+			afterParserOrEnumRuleCall();
+		}
+		kw='.'
+		{
+			$current.merge(kw);
+			newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1());
+		}
+	)+
+;
+
+RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F'|'_')+ ('#' (('b'|'B') ('i'|'I')|('l'|'L')))?;
+
+RULE_INT : '0'..'9' ('0'..'9'|'_')*;
+
+RULE_DECIMAL : RULE_INT (('e'|'E') ('+'|'-')? RULE_INT)? (('b'|'B') ('i'|'I'|'d'|'D')|('l'|'L'|'d'|'D'|'f'|'F'))?;
+
+RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'$'|'_') ('a'..'z'|'A'..'Z'|'$'|'_'|'0'..'9')*;
+
+RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'?|'\'' ('\\' .|~(('\\'|'\'')))* '\''?);
+
+RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';
+
+RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;
+
+RULE_WS : (' '|'\t'|'\r'|'\n')+;
+
+RULE_ANY_OTHER : .;
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens
new file mode 100644
index 0000000..483763b
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtype.tokens
@@ -0,0 +1,161 @@
+'!'=53
+'!='=38
+'!=='=40
+'#'=24
+'%'=52
+'%='=31
+'&&'=36
+'&'=88
+'('=20
+')'=22
+'*'=16
+'**'=50
+'*='=29
+'+'=48
+'++'=55
+'+='=27
+','=21
+'-'=49
+'--'=56
+'-='=28
+'->'=42
+'.'=57
+'..'=44
+'..<'=43
+'/'=51
+'/='=30
+':'=66
+'::'=58
+';'=18
+'<'=32
+'<>'=46
+'='=23
+'=='=37
+'==='=39
+'=>'=45
+'>'=33
+'>='=34
+'?'=87
+'?.'=59
+'?:'=47
+'@'=19
+'['=25
+']'=26
+'as'=54
+'case'=68
+'catch'=86
+'default'=67
+'do'=71
+'else'=64
+'extends'=74
+'extension'=15
+'false'=77
+'finally'=84
+'for'=69
+'if'=63
+'import'=13
+'instanceof'=41
+'new'=76
+'ns'=17
+'null'=79
+'return'=82
+'static'=14
+'super'=75
+'switch'=65
+'synchronized'=85
+'throw'=81
+'true'=78
+'try'=83
+'typeof'=80
+'val'=73
+'var'=72
+'while'=70
+'{'=60
+'|'=62
+'||'=35
+'}'=61
+RULE_ANY_OTHER=12
+RULE_DECIMAL=7
+RULE_HEX=5
+RULE_ID=8
+RULE_INT=6
+RULE_ML_COMMENT=9
+RULE_SL_COMMENT=10
+RULE_STRING=4
+RULE_WS=11
+T__13=13
+T__14=14
+T__15=15
+T__16=16
+T__17=17
+T__18=18
+T__19=19
+T__20=20
+T__21=21
+T__22=22
+T__23=23
+T__24=24
+T__25=25
+T__26=26
+T__27=27
+T__28=28
+T__29=29
+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
+T__40=40
+T__41=41
+T__42=42
+T__43=43
+T__44=44
+T__45=45
+T__46=46
+T__47=47
+T__48=48
+T__49=49
+T__50=50
+T__51=51
+T__52=52
+T__53=53
+T__54=54
+T__55=55
+T__56=56
+T__57=57
+T__58=58
+T__59=59
+T__60=60
+T__61=61
+T__62=62
+T__63=63
+T__64=64
+T__65=65
+T__66=66
+T__67=67
+T__68=68
+T__69=69
+T__70=70
+T__71=71
+T__72=72
+T__73=73
+T__74=74
+T__75=75
+T__76=76
+T__77=77
+T__78=78
+T__79=79
+T__80=80
+T__81=81
+T__82=82
+T__83=83
+T__84=84
+T__85=85
+T__86=86
+T__87=87
+T__88=88
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeLexer.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeLexer.java
new file mode 100644
index 0000000..aed79c6
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeLexer.java
@@ -0,0 +1,3533 @@
+package org.eclipse.osbp.xtext.oxtype.parser.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.parser.antlr.Lexer;
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+
+@SuppressWarnings("all")
+public class InternalOXtypeLexer extends Lexer {
+    public static final int RULE_HEX=5;
+    public static final int T__50=50;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__59=59;
+    public static final int T__16=16;
+    public static final int T__17=17;
+    public static final int T__18=18;
+    public static final int T__55=55;
+    public static final int T__56=56;
+    public static final int T__13=13;
+    public static final int T__57=57;
+    public static final int T__14=14;
+    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__60=60;
+    public static final int T__61=61;
+    public static final int RULE_ID=8;
+    public static final int RULE_DECIMAL=7;
+    public static final int T__26=26;
+    public static final int T__27=27;
+    public static final int T__28=28;
+    public static final int RULE_INT=6;
+    public static final int T__29=29;
+    public static final int T__22=22;
+    public static final int T__66=66;
+    public static final int RULE_ML_COMMENT=9;
+    public static final int T__23=23;
+    public static final int T__67=67;
+    public static final int T__24=24;
+    public static final int T__68=68;
+    public static final int T__25=25;
+    public static final int T__69=69;
+    public static final int T__62=62;
+    public static final int T__63=63;
+    public static final int T__20=20;
+    public static final int T__64=64;
+    public static final int T__21=21;
+    public static final int T__65=65;
+    public static final int T__70=70;
+    public static final int T__71=71;
+    public static final int T__72=72;
+    public static final int RULE_STRING=4;
+    public static final int RULE_SL_COMMENT=10;
+    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 T__33=33;
+    public static final int T__77=77;
+    public static final int T__34=34;
+    public static final int T__78=78;
+    public static final int T__35=35;
+    public static final int T__79=79;
+    public static final int T__36=36;
+    public static final int T__73=73;
+    public static final int EOF=-1;
+    public static final int T__30=30;
+    public static final int T__74=74;
+    public static final int T__31=31;
+    public static final int T__75=75;
+    public static final int T__32=32;
+    public static final int T__76=76;
+    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 RULE_WS=11;
+    public static final int RULE_ANY_OTHER=12;
+    public static final int T__48=48;
+    public static final int T__49=49;
+    public static final int T__44=44;
+    public static final int T__88=88;
+    public static final int T__45=45;
+    public static final int T__46=46;
+    public static final int T__47=47;
+    public static final int T__40=40;
+    public static final int T__84=84;
+    public static final int T__41=41;
+    public static final int T__85=85;
+    public static final int T__42=42;
+    public static final int T__86=86;
+    public static final int T__43=43;
+    public static final int T__87=87;
+
+    // delegates
+    // delegators
+
+    public InternalOXtypeLexer() {;} 
+    public InternalOXtypeLexer(CharStream input) {
+        this(input, new RecognizerSharedState());
+    }
+    public InternalOXtypeLexer(CharStream input, RecognizerSharedState state) {
+        super(input,state);
+
+    }
+    public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+    // $ANTLR start "T__13"
+    public final void mT__13() throws RecognitionException {
+        try {
+            int _type = T__13;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:11:7: ( 'import' )
+            // InternalOXtype.g:11:9: 'import'
+            {
+            match("import"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:12:7: ( 'static' )
+            // InternalOXtype.g:12:9: 'static'
+            {
+            match("static"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:13:7: ( 'extension' )
+            // InternalOXtype.g:13:9: 'extension'
+            {
+            match("extension"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:14:7: ( '*' )
+            // InternalOXtype.g:14:9: '*'
+            {
+            match('*'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:15:7: ( 'ns' )
+            // InternalOXtype.g:15:9: 'ns'
+            {
+            match("ns"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:16:7: ( ';' )
+            // InternalOXtype.g:16: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;
+            // InternalOXtype.g:17:7: ( '@' )
+            // InternalOXtype.g:17: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;
+            // InternalOXtype.g:18:7: ( '(' )
+            // InternalOXtype.g:18: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;
+            // InternalOXtype.g:19:7: ( ',' )
+            // InternalOXtype.g:19: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;
+            // InternalOXtype.g:20:7: ( ')' )
+            // InternalOXtype.g:20: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;
+            // InternalOXtype.g:21:7: ( '=' )
+            // InternalOXtype.g:21: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;
+            // InternalOXtype.g:22:7: ( '#' )
+            // InternalOXtype.g:22: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;
+            // InternalOXtype.g:23:7: ( '[' )
+            // InternalOXtype.g:23: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;
+            // InternalOXtype.g:24:7: ( ']' )
+            // InternalOXtype.g:24: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;
+            // InternalOXtype.g:25:7: ( '+=' )
+            // InternalOXtype.g:25: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;
+            // InternalOXtype.g:26:7: ( '-=' )
+            // InternalOXtype.g:26: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;
+            // InternalOXtype.g:27:7: ( '*=' )
+            // InternalOXtype.g:27: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;
+            // InternalOXtype.g:28:7: ( '/=' )
+            // InternalOXtype.g:28: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;
+            // InternalOXtype.g:29:7: ( '%=' )
+            // InternalOXtype.g:29: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;
+            // InternalOXtype.g:30:7: ( '<' )
+            // InternalOXtype.g:30: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;
+            // InternalOXtype.g:31:7: ( '>' )
+            // InternalOXtype.g:31:9: '>'
+            {
+            match('>'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:32:7: ( '>=' )
+            // InternalOXtype.g:32:9: '>='
+            {
+            match(">="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:33:7: ( '||' )
+            // InternalOXtype.g:33:9: '||'
+            {
+            match("||"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:34:7: ( '&&' )
+            // InternalOXtype.g:34:9: '&&'
+            {
+            match("&&"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:35:7: ( '==' )
+            // InternalOXtype.g:35:9: '=='
+            {
+            match("=="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:36:7: ( '!=' )
+            // InternalOXtype.g:36:9: '!='
+            {
+            match("!="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:37:7: ( '===' )
+            // InternalOXtype.g:37:9: '==='
+            {
+            match("==="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:38:7: ( '!==' )
+            // InternalOXtype.g:38:9: '!=='
+            {
+            match("!=="); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:39:7: ( 'instanceof' )
+            // InternalOXtype.g:39:9: 'instanceof'
+            {
+            match("instanceof"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:40:7: ( '->' )
+            // InternalOXtype.g:40:9: '->'
+            {
+            match("->"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:41:7: ( '..<' )
+            // InternalOXtype.g:41:9: '..<'
+            {
+            match("..<"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:42:7: ( '..' )
+            // InternalOXtype.g:42:9: '..'
+            {
+            match(".."); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:43:7: ( '=>' )
+            // InternalOXtype.g:43:9: '=>'
+            {
+            match("=>"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:44:7: ( '<>' )
+            // InternalOXtype.g:44:9: '<>'
+            {
+            match("<>"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:45:7: ( '?:' )
+            // InternalOXtype.g:45:9: '?:'
+            {
+            match("?:"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:46:7: ( '+' )
+            // InternalOXtype.g:46:9: '+'
+            {
+            match('+'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:47:7: ( '-' )
+            // InternalOXtype.g:47: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;
+            // InternalOXtype.g:48:7: ( '**' )
+            // InternalOXtype.g:48: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;
+            // InternalOXtype.g:49:7: ( '/' )
+            // InternalOXtype.g:49: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;
+            // InternalOXtype.g:50:7: ( '%' )
+            // InternalOXtype.g:50: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;
+            // InternalOXtype.g:51:7: ( '!' )
+            // InternalOXtype.g:51: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;
+            // InternalOXtype.g:52:7: ( 'as' )
+            // InternalOXtype.g:52:9: 'as'
+            {
+            match("as"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:53:7: ( '++' )
+            // InternalOXtype.g:53: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;
+            // InternalOXtype.g:54:7: ( '--' )
+            // InternalOXtype.g:54: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;
+            // InternalOXtype.g:55:7: ( '.' )
+            // InternalOXtype.g:55: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;
+            // InternalOXtype.g:56:7: ( '::' )
+            // InternalOXtype.g:56: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;
+            // InternalOXtype.g:57:7: ( '?.' )
+            // InternalOXtype.g:57: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;
+            // InternalOXtype.g:58:7: ( '{' )
+            // InternalOXtype.g:58: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;
+            // InternalOXtype.g:59:7: ( '}' )
+            // InternalOXtype.g:59:9: '}'
+            {
+            match('}'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:60:7: ( '|' )
+            // InternalOXtype.g:60:9: '|'
+            {
+            match('|'); 
+
+            }
+
+            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;
+            // InternalOXtype.g:61:7: ( 'if' )
+            // InternalOXtype.g:61:9: 'if'
+            {
+            match("if"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:62:7: ( 'else' )
+            // InternalOXtype.g:62:9: 'else'
+            {
+            match("else"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:63:7: ( 'switch' )
+            // InternalOXtype.g:63:9: 'switch'
+            {
+            match("switch"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:64:7: ( ':' )
+            // InternalOXtype.g:64: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;
+            // InternalOXtype.g:65:7: ( 'default' )
+            // InternalOXtype.g:65:9: 'default'
+            {
+            match("default"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:66:7: ( 'case' )
+            // InternalOXtype.g:66:9: 'case'
+            {
+            match("case"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:67:7: ( 'for' )
+            // InternalOXtype.g:67:9: 'for'
+            {
+            match("for"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:68:7: ( 'while' )
+            // InternalOXtype.g:68:9: 'while'
+            {
+            match("while"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:69:7: ( 'do' )
+            // InternalOXtype.g:69:9: 'do'
+            {
+            match("do"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:70:7: ( 'var' )
+            // InternalOXtype.g:70:9: 'var'
+            {
+            match("var"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:71:7: ( 'val' )
+            // InternalOXtype.g:71:9: 'val'
+            {
+            match("val"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:72:7: ( 'extends' )
+            // InternalOXtype.g:72:9: 'extends'
+            {
+            match("extends"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:73:7: ( 'super' )
+            // InternalOXtype.g:73:9: 'super'
+            {
+            match("super"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:74:7: ( 'new' )
+            // InternalOXtype.g:74:9: 'new'
+            {
+            match("new"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:75:7: ( 'false' )
+            // InternalOXtype.g:75:9: 'false'
+            {
+            match("false"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:76:7: ( 'true' )
+            // InternalOXtype.g:76:9: 'true'
+            {
+            match("true"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:77:7: ( 'null' )
+            // InternalOXtype.g:77:9: 'null'
+            {
+            match("null"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:78:7: ( 'typeof' )
+            // InternalOXtype.g:78:9: 'typeof'
+            {
+            match("typeof"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:79:7: ( 'throw' )
+            // InternalOXtype.g:79:9: 'throw'
+            {
+            match("throw"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:80:7: ( 'return' )
+            // InternalOXtype.g:80:9: 'return'
+            {
+            match("return"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:81:7: ( 'try' )
+            // InternalOXtype.g:81:9: 'try'
+            {
+            match("try"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:82:7: ( 'finally' )
+            // InternalOXtype.g:82:9: 'finally'
+            {
+            match("finally"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:83:7: ( 'synchronized' )
+            // InternalOXtype.g:83:9: 'synchronized'
+            {
+            match("synchronized"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:84:7: ( 'catch' )
+            // InternalOXtype.g:84:9: 'catch'
+            {
+            match("catch"); 
+
+
+            }
+
+            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;
+            // InternalOXtype.g:85:7: ( '?' )
+            // InternalOXtype.g:85: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;
+            // InternalOXtype.g:86:7: ( '&' )
+            // InternalOXtype.g:86:9: '&'
+            {
+            match('&'); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "T__88"
+
+    // $ANTLR start "RULE_HEX"
+    public final void mRULE_HEX() throws RecognitionException {
+        try {
+            int _type = RULE_HEX;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:6888:10: ( ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )? )
+            // InternalOXtype.g:6888:12: ( '0x' | '0X' ) ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+ ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+            {
+            // InternalOXtype.g:6888:12: ( '0x' | '0X' )
+            int alt1=2;
+            int LA1_0 = input.LA(1);
+
+            if ( (LA1_0=='0') ) {
+                int LA1_1 = input.LA(2);
+
+                if ( (LA1_1=='x') ) {
+                    alt1=1;
+                }
+                else if ( (LA1_1=='X') ) {
+                    alt1=2;
+                }
+                else {
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 1, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 1, 0, input);
+
+                throw nvae;
+            }
+            switch (alt1) {
+                case 1 :
+                    // InternalOXtype.g:6888:13: '0x'
+                    {
+                    match("0x"); 
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6888:18: '0X'
+                    {
+                    match("0X"); 
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:6888:24: ( '0' .. '9' | 'a' .. 'f' | 'A' .. 'F' | '_' )+
+            int cnt2=0;
+            loop2:
+            do {
+                int alt2=2;
+                int LA2_0 = input.LA(1);
+
+                if ( ((LA2_0>='0' && LA2_0<='9')||(LA2_0>='A' && LA2_0<='F')||LA2_0=='_'||(LA2_0>='a' && LA2_0<='f')) ) {
+                    alt2=1;
+                }
+
+
+                switch (alt2) {
+            	case 1 :
+            	    // InternalOXtype.g:
+            	    {
+            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||(input.LA(1)>='A' && input.LA(1)<='F')||input.LA(1)=='_'||(input.LA(1)>='a' && input.LA(1)<='f') ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    if ( cnt2 >= 1 ) break loop2;
+                        EarlyExitException eee =
+                            new EarlyExitException(2, input);
+                        throw eee;
+                }
+                cnt2++;
+            } while (true);
+
+            // InternalOXtype.g:6888:58: ( '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) ) )?
+            int alt4=2;
+            int LA4_0 = input.LA(1);
+
+            if ( (LA4_0=='#') ) {
+                alt4=1;
+            }
+            switch (alt4) {
+                case 1 :
+                    // InternalOXtype.g:6888:59: '#' ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+                    {
+                    match('#'); 
+                    // InternalOXtype.g:6888:63: ( ( 'b' | 'B' ) ( 'i' | 'I' ) | ( 'l' | 'L' ) )
+                    int alt3=2;
+                    int LA3_0 = input.LA(1);
+
+                    if ( (LA3_0=='B'||LA3_0=='b') ) {
+                        alt3=1;
+                    }
+                    else if ( (LA3_0=='L'||LA3_0=='l') ) {
+                        alt3=2;
+                    }
+                    else {
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 3, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt3) {
+                        case 1 :
+                            // InternalOXtype.g:6888:64: ( 'b' | 'B' ) ( 'i' | 'I' )
+                            {
+                            if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+                            if ( input.LA(1)=='I'||input.LA(1)=='i' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:6888:84: ( 'l' | 'L' )
+                            {
+                            if ( input.LA(1)=='L'||input.LA(1)=='l' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_HEX"
+
+    // $ANTLR start "RULE_INT"
+    public final void mRULE_INT() throws RecognitionException {
+        try {
+            int _type = RULE_INT;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:6890:10: ( '0' .. '9' ( '0' .. '9' | '_' )* )
+            // InternalOXtype.g:6890:12: '0' .. '9' ( '0' .. '9' | '_' )*
+            {
+            matchRange('0','9'); 
+            // InternalOXtype.g:6890:21: ( '0' .. '9' | '_' )*
+            loop5:
+            do {
+                int alt5=2;
+                int LA5_0 = input.LA(1);
+
+                if ( ((LA5_0>='0' && LA5_0<='9')||LA5_0=='_') ) {
+                    alt5=1;
+                }
+
+
+                switch (alt5) {
+            	case 1 :
+            	    // InternalOXtype.g:
+            	    {
+            	    if ( (input.LA(1)>='0' && input.LA(1)<='9')||input.LA(1)=='_' ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop5;
+                }
+            } while (true);
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_INT"
+
+    // $ANTLR start "RULE_DECIMAL"
+    public final void mRULE_DECIMAL() throws RecognitionException {
+        try {
+            int _type = RULE_DECIMAL;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:6892:14: ( RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )? )
+            // InternalOXtype.g:6892:16: RULE_INT ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )? ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+            {
+            mRULE_INT(); 
+            // InternalOXtype.g:6892:25: ( ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT )?
+            int alt7=2;
+            int LA7_0 = input.LA(1);
+
+            if ( (LA7_0=='E'||LA7_0=='e') ) {
+                alt7=1;
+            }
+            switch (alt7) {
+                case 1 :
+                    // InternalOXtype.g:6892:26: ( 'e' | 'E' ) ( '+' | '-' )? RULE_INT
+                    {
+                    if ( input.LA(1)=='E'||input.LA(1)=='e' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+                    // InternalOXtype.g:6892:36: ( '+' | '-' )?
+                    int alt6=2;
+                    int LA6_0 = input.LA(1);
+
+                    if ( (LA6_0=='+'||LA6_0=='-') ) {
+                        alt6=1;
+                    }
+                    switch (alt6) {
+                        case 1 :
+                            // InternalOXtype.g:
+                            {
+                            if ( input.LA(1)=='+'||input.LA(1)=='-' ) {
+                                input.consume();
+
+                            }
+                            else {
+                                MismatchedSetException mse = new MismatchedSetException(null,input);
+                                recover(mse);
+                                throw mse;}
+
+
+                            }
+                            break;
+
+                    }
+
+                    mRULE_INT(); 
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:6892:58: ( ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' ) | ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' ) )?
+            int alt8=3;
+            int LA8_0 = input.LA(1);
+
+            if ( (LA8_0=='B'||LA8_0=='b') ) {
+                alt8=1;
+            }
+            else if ( (LA8_0=='D'||LA8_0=='F'||LA8_0=='L'||LA8_0=='d'||LA8_0=='f'||LA8_0=='l') ) {
+                alt8=2;
+            }
+            switch (alt8) {
+                case 1 :
+                    // InternalOXtype.g:6892:59: ( 'b' | 'B' ) ( 'i' | 'I' | 'd' | 'D' )
+                    {
+                    if ( input.LA(1)=='B'||input.LA(1)=='b' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+                    if ( input.LA(1)=='D'||input.LA(1)=='I'||input.LA(1)=='d'||input.LA(1)=='i' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6892:87: ( 'l' | 'L' | 'd' | 'D' | 'f' | 'F' )
+                    {
+                    if ( input.LA(1)=='D'||input.LA(1)=='F'||input.LA(1)=='L'||input.LA(1)=='d'||input.LA(1)=='f'||input.LA(1)=='l' ) {
+                        input.consume();
+
+                    }
+                    else {
+                        MismatchedSetException mse = new MismatchedSetException(null,input);
+                        recover(mse);
+                        throw mse;}
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_DECIMAL"
+
+    // $ANTLR start "RULE_ID"
+    public final void mRULE_ID() throws RecognitionException {
+        try {
+            int _type = RULE_ID;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:6894:9: ( ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )* )
+            // InternalOXtype.g:6894:11: ( '^' )? ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' ) ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+            {
+            // InternalOXtype.g:6894:11: ( '^' )?
+            int alt9=2;
+            int LA9_0 = input.LA(1);
+
+            if ( (LA9_0=='^') ) {
+                alt9=1;
+            }
+            switch (alt9) {
+                case 1 :
+                    // InternalOXtype.g:6894:11: '^'
+                    {
+                    match('^'); 
+
+                    }
+                    break;
+
+            }
+
+            if ( input.LA(1)=='$'||(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;}
+
+            // InternalOXtype.g:6894:44: ( 'a' .. 'z' | 'A' .. 'Z' | '$' | '_' | '0' .. '9' )*
+            loop10:
+            do {
+                int alt10=2;
+                int LA10_0 = input.LA(1);
+
+                if ( (LA10_0=='$'||(LA10_0>='0' && LA10_0<='9')||(LA10_0>='A' && LA10_0<='Z')||LA10_0=='_'||(LA10_0>='a' && LA10_0<='z')) ) {
+                    alt10=1;
+                }
+
+
+                switch (alt10) {
+            	case 1 :
+            	    // InternalOXtype.g:
+            	    {
+            	    if ( input.LA(1)=='$'||(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 loop10;
+                }
+            } while (true);
+
+
+            }
+
+            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;
+            // InternalOXtype.g:6896:13: ( ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? ) )
+            // InternalOXtype.g:6896:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+            {
+            // InternalOXtype.g:6896:15: ( '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )? | '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )? )
+            int alt15=2;
+            int LA15_0 = input.LA(1);
+
+            if ( (LA15_0=='\"') ) {
+                alt15=1;
+            }
+            else if ( (LA15_0=='\'') ) {
+                alt15=2;
+            }
+            else {
+                NoViableAltException nvae =
+                    new NoViableAltException("", 15, 0, input);
+
+                throw nvae;
+            }
+            switch (alt15) {
+                case 1 :
+                    // InternalOXtype.g:6896:16: '\"' ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )* ( '\"' )?
+                    {
+                    match('\"'); 
+                    // InternalOXtype.g:6896:20: ( '\\\\' . | ~ ( ( '\\\\' | '\"' ) ) )*
+                    loop11:
+                    do {
+                        int alt11=3;
+                        int LA11_0 = input.LA(1);
+
+                        if ( (LA11_0=='\\') ) {
+                            alt11=1;
+                        }
+                        else if ( ((LA11_0>='\u0000' && LA11_0<='!')||(LA11_0>='#' && LA11_0<='[')||(LA11_0>=']' && LA11_0<='\uFFFF')) ) {
+                            alt11=2;
+                        }
+
+
+                        switch (alt11) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6896:21: '\\\\' .
+                    	    {
+                    	    match('\\'); 
+                    	    matchAny(); 
+
+                    	    }
+                    	    break;
+                    	case 2 :
+                    	    // InternalOXtype.g:6896:28: ~ ( ( '\\\\' | '\"' ) )
+                    	    {
+                    	    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 loop11;
+                        }
+                    } while (true);
+
+                    // InternalOXtype.g:6896:44: ( '\"' )?
+                    int alt12=2;
+                    int LA12_0 = input.LA(1);
+
+                    if ( (LA12_0=='\"') ) {
+                        alt12=1;
+                    }
+                    switch (alt12) {
+                        case 1 :
+                            // InternalOXtype.g:6896:44: '\"'
+                            {
+                            match('\"'); 
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6896:49: '\\'' ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )* ( '\\'' )?
+                    {
+                    match('\''); 
+                    // InternalOXtype.g:6896:54: ( '\\\\' . | ~ ( ( '\\\\' | '\\'' ) ) )*
+                    loop13:
+                    do {
+                        int alt13=3;
+                        int LA13_0 = input.LA(1);
+
+                        if ( (LA13_0=='\\') ) {
+                            alt13=1;
+                        }
+                        else if ( ((LA13_0>='\u0000' && LA13_0<='&')||(LA13_0>='(' && LA13_0<='[')||(LA13_0>=']' && LA13_0<='\uFFFF')) ) {
+                            alt13=2;
+                        }
+
+
+                        switch (alt13) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6896:55: '\\\\' .
+                    	    {
+                    	    match('\\'); 
+                    	    matchAny(); 
+
+                    	    }
+                    	    break;
+                    	case 2 :
+                    	    // InternalOXtype.g:6896:62: ~ ( ( '\\\\' | '\\'' ) )
+                    	    {
+                    	    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 loop13;
+                        }
+                    } while (true);
+
+                    // InternalOXtype.g:6896:79: ( '\\'' )?
+                    int alt14=2;
+                    int LA14_0 = input.LA(1);
+
+                    if ( (LA14_0=='\'') ) {
+                        alt14=1;
+                    }
+                    switch (alt14) {
+                        case 1 :
+                            // InternalOXtype.g:6896:79: '\\''
+                            {
+                            match('\''); 
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            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;
+            // InternalOXtype.g:6898:17: ( '/*' ( options {greedy=false; } : . )* '*/' )
+            // InternalOXtype.g:6898:19: '/*' ( options {greedy=false; } : . )* '*/'
+            {
+            match("/*"); 
+
+            // InternalOXtype.g:6898:24: ( options {greedy=false; } : . )*
+            loop16:
+            do {
+                int alt16=2;
+                int LA16_0 = input.LA(1);
+
+                if ( (LA16_0=='*') ) {
+                    int LA16_1 = input.LA(2);
+
+                    if ( (LA16_1=='/') ) {
+                        alt16=2;
+                    }
+                    else if ( ((LA16_1>='\u0000' && LA16_1<='.')||(LA16_1>='0' && LA16_1<='\uFFFF')) ) {
+                        alt16=1;
+                    }
+
+
+                }
+                else if ( ((LA16_0>='\u0000' && LA16_0<=')')||(LA16_0>='+' && LA16_0<='\uFFFF')) ) {
+                    alt16=1;
+                }
+
+
+                switch (alt16) {
+            	case 1 :
+            	    // InternalOXtype.g:6898:52: .
+            	    {
+            	    matchAny(); 
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop16;
+                }
+            } 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;
+            // InternalOXtype.g:6900:17: ( '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )? )
+            // InternalOXtype.g:6900:19: '//' (~ ( ( '\\n' | '\\r' ) ) )* ( ( '\\r' )? '\\n' )?
+            {
+            match("//"); 
+
+            // InternalOXtype.g:6900:24: (~ ( ( '\\n' | '\\r' ) ) )*
+            loop17:
+            do {
+                int alt17=2;
+                int LA17_0 = input.LA(1);
+
+                if ( ((LA17_0>='\u0000' && LA17_0<='\t')||(LA17_0>='\u000B' && LA17_0<='\f')||(LA17_0>='\u000E' && LA17_0<='\uFFFF')) ) {
+                    alt17=1;
+                }
+
+
+                switch (alt17) {
+            	case 1 :
+            	    // InternalOXtype.g:6900: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)<='\uFFFF') ) {
+            	        input.consume();
+
+            	    }
+            	    else {
+            	        MismatchedSetException mse = new MismatchedSetException(null,input);
+            	        recover(mse);
+            	        throw mse;}
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop17;
+                }
+            } while (true);
+
+            // InternalOXtype.g:6900:40: ( ( '\\r' )? '\\n' )?
+            int alt19=2;
+            int LA19_0 = input.LA(1);
+
+            if ( (LA19_0=='\n'||LA19_0=='\r') ) {
+                alt19=1;
+            }
+            switch (alt19) {
+                case 1 :
+                    // InternalOXtype.g:6900:41: ( '\\r' )? '\\n'
+                    {
+                    // InternalOXtype.g:6900:41: ( '\\r' )?
+                    int alt18=2;
+                    int LA18_0 = input.LA(1);
+
+                    if ( (LA18_0=='\r') ) {
+                        alt18=1;
+                    }
+                    switch (alt18) {
+                        case 1 :
+                            // InternalOXtype.g:6900:41: '\\r'
+                            {
+                            match('\r'); 
+
+                            }
+                            break;
+
+                    }
+
+                    match('\n'); 
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_SL_COMMENT"
+
+    // $ANTLR start "RULE_WS"
+    public final void mRULE_WS() throws RecognitionException {
+        try {
+            int _type = RULE_WS;
+            int _channel = DEFAULT_TOKEN_CHANNEL;
+            // InternalOXtype.g:6902:9: ( ( ' ' | '\\t' | '\\r' | '\\n' )+ )
+            // InternalOXtype.g:6902:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            {
+            // InternalOXtype.g:6902:11: ( ' ' | '\\t' | '\\r' | '\\n' )+
+            int cnt20=0;
+            loop20:
+            do {
+                int alt20=2;
+                int LA20_0 = input.LA(1);
+
+                if ( ((LA20_0>='\t' && LA20_0<='\n')||LA20_0=='\r'||LA20_0==' ') ) {
+                    alt20=1;
+                }
+
+
+                switch (alt20) {
+            	case 1 :
+            	    // InternalOXtype.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 ( cnt20 >= 1 ) break loop20;
+                        EarlyExitException eee =
+                            new EarlyExitException(20, input);
+                        throw eee;
+                }
+                cnt20++;
+            } 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;
+            // InternalOXtype.g:6904:16: ( . )
+            // InternalOXtype.g:6904:18: .
+            {
+            matchAny(); 
+
+            }
+
+            state.type = _type;
+            state.channel = _channel;
+        }
+        finally {
+        }
+    }
+    // $ANTLR end "RULE_ANY_OTHER"
+
+    public void mTokens() throws RecognitionException {
+        // InternalOXtype.g:1:8: ( 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 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | RULE_WS | RULE_ANY_OTHER )
+        int alt21=85;
+        alt21 = dfa21.predict(input);
+        switch (alt21) {
+            case 1 :
+                // InternalOXtype.g:1:10: T__13
+                {
+                mT__13(); 
+
+                }
+                break;
+            case 2 :
+                // InternalOXtype.g:1:16: T__14
+                {
+                mT__14(); 
+
+                }
+                break;
+            case 3 :
+                // InternalOXtype.g:1:22: T__15
+                {
+                mT__15(); 
+
+                }
+                break;
+            case 4 :
+                // InternalOXtype.g:1:28: T__16
+                {
+                mT__16(); 
+
+                }
+                break;
+            case 5 :
+                // InternalOXtype.g:1:34: T__17
+                {
+                mT__17(); 
+
+                }
+                break;
+            case 6 :
+                // InternalOXtype.g:1:40: T__18
+                {
+                mT__18(); 
+
+                }
+                break;
+            case 7 :
+                // InternalOXtype.g:1:46: T__19
+                {
+                mT__19(); 
+
+                }
+                break;
+            case 8 :
+                // InternalOXtype.g:1:52: T__20
+                {
+                mT__20(); 
+
+                }
+                break;
+            case 9 :
+                // InternalOXtype.g:1:58: T__21
+                {
+                mT__21(); 
+
+                }
+                break;
+            case 10 :
+                // InternalOXtype.g:1:64: T__22
+                {
+                mT__22(); 
+
+                }
+                break;
+            case 11 :
+                // InternalOXtype.g:1:70: T__23
+                {
+                mT__23(); 
+
+                }
+                break;
+            case 12 :
+                // InternalOXtype.g:1:76: T__24
+                {
+                mT__24(); 
+
+                }
+                break;
+            case 13 :
+                // InternalOXtype.g:1:82: T__25
+                {
+                mT__25(); 
+
+                }
+                break;
+            case 14 :
+                // InternalOXtype.g:1:88: T__26
+                {
+                mT__26(); 
+
+                }
+                break;
+            case 15 :
+                // InternalOXtype.g:1:94: T__27
+                {
+                mT__27(); 
+
+                }
+                break;
+            case 16 :
+                // InternalOXtype.g:1:100: T__28
+                {
+                mT__28(); 
+
+                }
+                break;
+            case 17 :
+                // InternalOXtype.g:1:106: T__29
+                {
+                mT__29(); 
+
+                }
+                break;
+            case 18 :
+                // InternalOXtype.g:1:112: T__30
+                {
+                mT__30(); 
+
+                }
+                break;
+            case 19 :
+                // InternalOXtype.g:1:118: T__31
+                {
+                mT__31(); 
+
+                }
+                break;
+            case 20 :
+                // InternalOXtype.g:1:124: T__32
+                {
+                mT__32(); 
+
+                }
+                break;
+            case 21 :
+                // InternalOXtype.g:1:130: T__33
+                {
+                mT__33(); 
+
+                }
+                break;
+            case 22 :
+                // InternalOXtype.g:1:136: T__34
+                {
+                mT__34(); 
+
+                }
+                break;
+            case 23 :
+                // InternalOXtype.g:1:142: T__35
+                {
+                mT__35(); 
+
+                }
+                break;
+            case 24 :
+                // InternalOXtype.g:1:148: T__36
+                {
+                mT__36(); 
+
+                }
+                break;
+            case 25 :
+                // InternalOXtype.g:1:154: T__37
+                {
+                mT__37(); 
+
+                }
+                break;
+            case 26 :
+                // InternalOXtype.g:1:160: T__38
+                {
+                mT__38(); 
+
+                }
+                break;
+            case 27 :
+                // InternalOXtype.g:1:166: T__39
+                {
+                mT__39(); 
+
+                }
+                break;
+            case 28 :
+                // InternalOXtype.g:1:172: T__40
+                {
+                mT__40(); 
+
+                }
+                break;
+            case 29 :
+                // InternalOXtype.g:1:178: T__41
+                {
+                mT__41(); 
+
+                }
+                break;
+            case 30 :
+                // InternalOXtype.g:1:184: T__42
+                {
+                mT__42(); 
+
+                }
+                break;
+            case 31 :
+                // InternalOXtype.g:1:190: T__43
+                {
+                mT__43(); 
+
+                }
+                break;
+            case 32 :
+                // InternalOXtype.g:1:196: T__44
+                {
+                mT__44(); 
+
+                }
+                break;
+            case 33 :
+                // InternalOXtype.g:1:202: T__45
+                {
+                mT__45(); 
+
+                }
+                break;
+            case 34 :
+                // InternalOXtype.g:1:208: T__46
+                {
+                mT__46(); 
+
+                }
+                break;
+            case 35 :
+                // InternalOXtype.g:1:214: T__47
+                {
+                mT__47(); 
+
+                }
+                break;
+            case 36 :
+                // InternalOXtype.g:1:220: T__48
+                {
+                mT__48(); 
+
+                }
+                break;
+            case 37 :
+                // InternalOXtype.g:1:226: T__49
+                {
+                mT__49(); 
+
+                }
+                break;
+            case 38 :
+                // InternalOXtype.g:1:232: T__50
+                {
+                mT__50(); 
+
+                }
+                break;
+            case 39 :
+                // InternalOXtype.g:1:238: T__51
+                {
+                mT__51(); 
+
+                }
+                break;
+            case 40 :
+                // InternalOXtype.g:1:244: T__52
+                {
+                mT__52(); 
+
+                }
+                break;
+            case 41 :
+                // InternalOXtype.g:1:250: T__53
+                {
+                mT__53(); 
+
+                }
+                break;
+            case 42 :
+                // InternalOXtype.g:1:256: T__54
+                {
+                mT__54(); 
+
+                }
+                break;
+            case 43 :
+                // InternalOXtype.g:1:262: T__55
+                {
+                mT__55(); 
+
+                }
+                break;
+            case 44 :
+                // InternalOXtype.g:1:268: T__56
+                {
+                mT__56(); 
+
+                }
+                break;
+            case 45 :
+                // InternalOXtype.g:1:274: T__57
+                {
+                mT__57(); 
+
+                }
+                break;
+            case 46 :
+                // InternalOXtype.g:1:280: T__58
+                {
+                mT__58(); 
+
+                }
+                break;
+            case 47 :
+                // InternalOXtype.g:1:286: T__59
+                {
+                mT__59(); 
+
+                }
+                break;
+            case 48 :
+                // InternalOXtype.g:1:292: T__60
+                {
+                mT__60(); 
+
+                }
+                break;
+            case 49 :
+                // InternalOXtype.g:1:298: T__61
+                {
+                mT__61(); 
+
+                }
+                break;
+            case 50 :
+                // InternalOXtype.g:1:304: T__62
+                {
+                mT__62(); 
+
+                }
+                break;
+            case 51 :
+                // InternalOXtype.g:1:310: T__63
+                {
+                mT__63(); 
+
+                }
+                break;
+            case 52 :
+                // InternalOXtype.g:1:316: T__64
+                {
+                mT__64(); 
+
+                }
+                break;
+            case 53 :
+                // InternalOXtype.g:1:322: T__65
+                {
+                mT__65(); 
+
+                }
+                break;
+            case 54 :
+                // InternalOXtype.g:1:328: T__66
+                {
+                mT__66(); 
+
+                }
+                break;
+            case 55 :
+                // InternalOXtype.g:1:334: T__67
+                {
+                mT__67(); 
+
+                }
+                break;
+            case 56 :
+                // InternalOXtype.g:1:340: T__68
+                {
+                mT__68(); 
+
+                }
+                break;
+            case 57 :
+                // InternalOXtype.g:1:346: T__69
+                {
+                mT__69(); 
+
+                }
+                break;
+            case 58 :
+                // InternalOXtype.g:1:352: T__70
+                {
+                mT__70(); 
+
+                }
+                break;
+            case 59 :
+                // InternalOXtype.g:1:358: T__71
+                {
+                mT__71(); 
+
+                }
+                break;
+            case 60 :
+                // InternalOXtype.g:1:364: T__72
+                {
+                mT__72(); 
+
+                }
+                break;
+            case 61 :
+                // InternalOXtype.g:1:370: T__73
+                {
+                mT__73(); 
+
+                }
+                break;
+            case 62 :
+                // InternalOXtype.g:1:376: T__74
+                {
+                mT__74(); 
+
+                }
+                break;
+            case 63 :
+                // InternalOXtype.g:1:382: T__75
+                {
+                mT__75(); 
+
+                }
+                break;
+            case 64 :
+                // InternalOXtype.g:1:388: T__76
+                {
+                mT__76(); 
+
+                }
+                break;
+            case 65 :
+                // InternalOXtype.g:1:394: T__77
+                {
+                mT__77(); 
+
+                }
+                break;
+            case 66 :
+                // InternalOXtype.g:1:400: T__78
+                {
+                mT__78(); 
+
+                }
+                break;
+            case 67 :
+                // InternalOXtype.g:1:406: T__79
+                {
+                mT__79(); 
+
+                }
+                break;
+            case 68 :
+                // InternalOXtype.g:1:412: T__80
+                {
+                mT__80(); 
+
+                }
+                break;
+            case 69 :
+                // InternalOXtype.g:1:418: T__81
+                {
+                mT__81(); 
+
+                }
+                break;
+            case 70 :
+                // InternalOXtype.g:1:424: T__82
+                {
+                mT__82(); 
+
+                }
+                break;
+            case 71 :
+                // InternalOXtype.g:1:430: T__83
+                {
+                mT__83(); 
+
+                }
+                break;
+            case 72 :
+                // InternalOXtype.g:1:436: T__84
+                {
+                mT__84(); 
+
+                }
+                break;
+            case 73 :
+                // InternalOXtype.g:1:442: T__85
+                {
+                mT__85(); 
+
+                }
+                break;
+            case 74 :
+                // InternalOXtype.g:1:448: T__86
+                {
+                mT__86(); 
+
+                }
+                break;
+            case 75 :
+                // InternalOXtype.g:1:454: T__87
+                {
+                mT__87(); 
+
+                }
+                break;
+            case 76 :
+                // InternalOXtype.g:1:460: T__88
+                {
+                mT__88(); 
+
+                }
+                break;
+            case 77 :
+                // InternalOXtype.g:1:466: RULE_HEX
+                {
+                mRULE_HEX(); 
+
+                }
+                break;
+            case 78 :
+                // InternalOXtype.g:1:475: RULE_INT
+                {
+                mRULE_INT(); 
+
+                }
+                break;
+            case 79 :
+                // InternalOXtype.g:1:484: RULE_DECIMAL
+                {
+                mRULE_DECIMAL(); 
+
+                }
+                break;
+            case 80 :
+                // InternalOXtype.g:1:497: RULE_ID
+                {
+                mRULE_ID(); 
+
+                }
+                break;
+            case 81 :
+                // InternalOXtype.g:1:505: RULE_STRING
+                {
+                mRULE_STRING(); 
+
+                }
+                break;
+            case 82 :
+                // InternalOXtype.g:1:517: RULE_ML_COMMENT
+                {
+                mRULE_ML_COMMENT(); 
+
+                }
+                break;
+            case 83 :
+                // InternalOXtype.g:1:533: RULE_SL_COMMENT
+                {
+                mRULE_SL_COMMENT(); 
+
+                }
+                break;
+            case 84 :
+                // InternalOXtype.g:1:549: RULE_WS
+                {
+                mRULE_WS(); 
+
+                }
+                break;
+            case 85 :
+                // InternalOXtype.g:1:557: RULE_ANY_OTHER
+                {
+                mRULE_ANY_OTHER(); 
+
+                }
+                break;
+
+        }
+
+    }
+
+
+    protected DFA21 dfa21 = new DFA21(this);
+    static final String DFA21_eotS =
+        "\1\uffff\3\60\1\71\1\60\5\uffff\1\104\3\uffff\1\112\1\116\1\122\1\124\1\126\1\130\1\132\1\134\1\136\1\140\1\143\1\60\1\146\2\uffff\7\60\2\167\1\54\5\uffff\2\60\1\175\1\uffff\6\60\3\uffff\1\u0084\2\60\5\uffff\1\u0088\32\uffff\1\u008a\1\uffff\1\u008c\4\uffff\1\u008d\4\uffff\1\60\1\u008f\12\60\1\uffff\1\167\4\uffff\2\60\1\uffff\6\60\1\uffff\1\u00a5\1\60\7\uffff\1\60\1\uffff\2\60\1\u00aa\3\60\1\u00ae\1\u00af\1\60\1\u00b1\12\60\1\u00bc\1\uffff\1\u00bd\1\60\1\u00bf\1\60\1\uffff\3\60\2\uffff\1\u00c4\1\uffff\7\60\1\u00cc\2\60\2\uffff\1\60\1\uffff\1\u00d1\1\u00d2\1\60\1\u00d4\1\uffff\1\60\1\u00d6\1\60\1\u00d8\1\60\1\u00da\1\u00db\1\uffff\4\60\2\uffff\1\60\1\uffff\1\u00e1\1\uffff\1\u00e2\1\uffff\1\60\2\uffff\2\60\1\u00e6\1\u00e7\1\u00e8\2\uffff\3\60\3\uffff\2\60\1\u00ee\1\u00ef\1\60\2\uffff\1\60\1\u00f2\1\uffff";
+    static final String DFA21_eofS =
+        "\u00f3\uffff";
+    static final String DFA21_minS =
+        "\1\0\1\146\1\164\1\154\1\52\1\145\5\uffff\1\75\3\uffff\1\53\1\55\1\52\1\75\1\76\1\75\1\174\1\46\1\75\2\56\1\163\1\72\2\uffff\1\145\2\141\1\150\1\141\1\150\1\145\2\60\1\44\5\uffff\1\160\1\163\1\44\1\uffff\1\141\1\151\1\160\1\156\1\164\1\163\3\uffff\1\44\1\167\1\154\5\uffff\1\75\32\uffff\1\75\1\uffff\1\74\4\uffff\1\44\4\uffff\1\146\1\44\1\163\1\162\1\154\1\156\1\151\1\154\1\165\1\160\1\162\1\164\1\uffff\1\60\4\uffff\1\157\1\164\1\uffff\2\164\1\145\1\143\2\145\1\uffff\1\44\1\154\7\uffff\1\141\1\uffff\1\145\1\143\1\44\1\163\1\141\1\154\2\44\1\145\1\44\1\145\1\157\1\165\1\162\1\141\1\151\1\143\1\162\1\150\1\156\1\44\1\uffff\1\44\1\165\1\44\1\150\1\uffff\1\145\1\154\1\145\2\uffff\1\44\1\uffff\1\157\1\167\1\162\1\164\1\156\1\143\1\150\1\44\1\162\1\144\2\uffff\1\154\1\uffff\2\44\1\154\1\44\1\uffff\1\146\1\44\1\156\1\44\1\143\2\44\1\uffff\1\157\1\151\1\163\1\164\2\uffff\1\171\1\uffff\1\44\1\uffff\1\44\1\uffff\1\145\2\uffff\1\156\1\157\3\44\2\uffff\1\157\1\151\1\156\3\uffff\1\146\1\172\2\44\1\145\2\uffff\1\144\1\44\1\uffff";
+    static final String DFA21_maxS =
+        "\1\uffff\1\156\1\171\1\170\1\75\1\165\5\uffff\1\76\3\uffff\1\75\1\76\2\75\1\76\1\75\1\174\1\46\1\75\1\56\1\72\1\163\1\72\2\uffff\1\157\1\141\1\157\1\150\1\141\1\171\1\145\1\170\1\154\1\172\5\uffff\1\160\1\163\1\172\1\uffff\1\141\1\151\1\160\1\156\1\164\1\163\3\uffff\1\172\1\167\1\154\5\uffff\1\75\32\uffff\1\75\1\uffff\1\74\4\uffff\1\172\4\uffff\1\146\1\172\1\164\1\162\1\154\1\156\1\151\1\162\1\171\1\160\1\162\1\164\1\uffff\1\154\4\uffff\1\157\1\164\1\uffff\2\164\1\145\1\143\2\145\1\uffff\1\172\1\154\7\uffff\1\141\1\uffff\1\145\1\143\1\172\1\163\1\141\1\154\2\172\1\145\1\172\1\145\1\157\1\165\1\162\1\141\1\151\1\143\1\162\1\150\1\156\1\172\1\uffff\1\172\1\165\1\172\1\150\1\uffff\1\145\1\154\1\145\2\uffff\1\172\1\uffff\1\157\1\167\1\162\1\164\1\156\1\143\1\150\1\172\1\162\1\163\2\uffff\1\154\1\uffff\2\172\1\154\1\172\1\uffff\1\146\1\172\1\156\1\172\1\143\2\172\1\uffff\1\157\1\151\1\163\1\164\2\uffff\1\171\1\uffff\1\172\1\uffff\1\172\1\uffff\1\145\2\uffff\1\156\1\157\3\172\2\uffff\1\157\1\151\1\156\3\uffff\1\146\3\172\1\145\2\uffff\1\144\1\172\1\uffff";
+    static final String DFA21_acceptS =
+        "\6\uffff\1\6\1\7\1\10\1\11\1\12\1\uffff\1\14\1\15\1\16\15\uffff\1\60\1\61\12\uffff\1\120\2\121\1\124\1\125\3\uffff\1\120\6\uffff\1\21\1\46\1\4\3\uffff\1\6\1\7\1\10\1\11\1\12\1\uffff\1\41\1\13\1\14\1\15\1\16\1\17\1\53\1\44\1\20\1\36\1\54\1\45\1\22\1\122\1\123\1\47\1\23\1\50\1\42\1\24\1\26\1\25\1\27\1\62\1\30\1\114\1\uffff\1\51\1\uffff\1\55\1\43\1\57\1\113\1\uffff\1\56\1\66\1\60\1\61\14\uffff\1\115\1\uffff\1\116\1\117\1\121\1\124\2\uffff\1\63\6\uffff\1\5\2\uffff\1\33\1\31\1\34\1\32\1\37\1\40\1\52\1\uffff\1\73\25\uffff\1\100\4\uffff\1\71\3\uffff\1\74\1\75\1\uffff\1\107\12\uffff\1\64\1\103\1\uffff\1\70\4\uffff\1\102\7\uffff\1\77\4\uffff\1\112\1\101\1\uffff\1\72\1\uffff\1\105\1\uffff\1\1\1\uffff\1\2\1\65\5\uffff\1\104\1\106\3\uffff\1\76\1\67\1\110\5\uffff\1\3\1\35\2\uffff\1\111";
+    static final String DFA21_specialS =
+        "\1\0\u00f2\uffff}>";
+    static final String[] DFA21_transitionS = {
+            "\11\54\2\53\2\54\1\53\22\54\1\53\1\27\1\51\1\14\1\50\1\22\1\26\1\52\1\10\1\12\1\4\1\17\1\11\1\20\1\30\1\21\1\45\11\46\1\33\1\6\1\23\1\13\1\24\1\31\1\7\32\50\1\15\1\54\1\16\1\47\1\50\1\54\1\32\1\50\1\37\1\36\1\3\1\40\2\50\1\1\4\50\1\5\3\50\1\44\1\2\1\43\1\50\1\42\1\41\3\50\1\34\1\25\1\35\uff82\54",
+            "\1\57\6\uffff\1\55\1\56",
+            "\1\61\1\63\1\uffff\1\62\1\uffff\1\64",
+            "\1\66\13\uffff\1\65",
+            "\1\70\22\uffff\1\67",
+            "\1\73\15\uffff\1\72\1\uffff\1\74",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\102\1\103",
+            "",
+            "",
+            "",
+            "\1\111\21\uffff\1\110",
+            "\1\115\17\uffff\1\113\1\114",
+            "\1\120\4\uffff\1\121\15\uffff\1\117",
+            "\1\123",
+            "\1\125",
+            "\1\127",
+            "\1\131",
+            "\1\133",
+            "\1\135",
+            "\1\137",
+            "\1\142\13\uffff\1\141",
+            "\1\144",
+            "\1\145",
+            "",
+            "",
+            "\1\151\11\uffff\1\152",
+            "\1\153",
+            "\1\155\7\uffff\1\156\5\uffff\1\154",
+            "\1\157",
+            "\1\160",
+            "\1\163\11\uffff\1\161\6\uffff\1\162",
+            "\1\164",
+            "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165\6\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170\13\uffff\1\165",
+            "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+            "\1\60\34\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\173",
+            "\1\174",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\176",
+            "\1\177",
+            "\1\u0080",
+            "\1\u0081",
+            "\1\u0082",
+            "\1\u0083",
+            "",
+            "",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u0085",
+            "\1\u0086",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\u0087",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\u0089",
+            "",
+            "\1\u008b",
+            "",
+            "",
+            "",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "",
+            "",
+            "",
+            "\1\u008e",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u0090\1\u0091",
+            "\1\u0092",
+            "\1\u0093",
+            "\1\u0094",
+            "\1\u0095",
+            "\1\u0097\5\uffff\1\u0096",
+            "\1\u0098\3\uffff\1\u0099",
+            "\1\u009a",
+            "\1\u009b",
+            "\1\u009c",
+            "",
+            "\12\166\10\uffff\1\170\1\uffff\3\170\5\uffff\1\170\22\uffff\1\166\2\uffff\1\170\1\uffff\3\170\5\uffff\1\170",
+            "",
+            "",
+            "",
+            "",
+            "\1\u009d",
+            "\1\u009e",
+            "",
+            "\1\u009f",
+            "\1\u00a0",
+            "\1\u00a1",
+            "\1\u00a2",
+            "\1\u00a3",
+            "\1\u00a4",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00a6",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\u00a7",
+            "",
+            "\1\u00a8",
+            "\1\u00a9",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00ab",
+            "\1\u00ac",
+            "\1\u00ad",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00b0",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00b2",
+            "\1\u00b3",
+            "\1\u00b4",
+            "\1\u00b5",
+            "\1\u00b6",
+            "\1\u00b7",
+            "\1\u00b8",
+            "\1\u00b9",
+            "\1\u00ba",
+            "\1\u00bb",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00be",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00c0",
+            "",
+            "\1\u00c1",
+            "\1\u00c2",
+            "\1\u00c3",
+            "",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\u00c5",
+            "\1\u00c6",
+            "\1\u00c7",
+            "\1\u00c8",
+            "\1\u00c9",
+            "\1\u00ca",
+            "\1\u00cb",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00cd",
+            "\1\u00cf\16\uffff\1\u00ce",
+            "",
+            "",
+            "\1\u00d0",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00d3",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\u00d5",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00d7",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00d9",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\u00dc",
+            "\1\u00dd",
+            "\1\u00de",
+            "\1\u00df",
+            "",
+            "",
+            "\1\u00e0",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "\1\u00e3",
+            "",
+            "",
+            "\1\u00e4",
+            "\1\u00e5",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "",
+            "",
+            "\1\u00e9",
+            "\1\u00ea",
+            "\1\u00eb",
+            "",
+            "",
+            "",
+            "\1\u00ec",
+            "\1\u00ed",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            "\1\u00f0",
+            "",
+            "",
+            "\1\u00f1",
+            "\1\60\13\uffff\12\60\7\uffff\32\60\4\uffff\1\60\1\uffff\32\60",
+            ""
+    };
+
+    static final short[] DFA21_eot = DFA.unpackEncodedString(DFA21_eotS);
+    static final short[] DFA21_eof = DFA.unpackEncodedString(DFA21_eofS);
+    static final char[] DFA21_min = DFA.unpackEncodedStringToUnsignedChars(DFA21_minS);
+    static final char[] DFA21_max = DFA.unpackEncodedStringToUnsignedChars(DFA21_maxS);
+    static final short[] DFA21_accept = DFA.unpackEncodedString(DFA21_acceptS);
+    static final short[] DFA21_special = DFA.unpackEncodedString(DFA21_specialS);
+    static final short[][] DFA21_transition;
+
+    static {
+        int numStates = DFA21_transitionS.length;
+        DFA21_transition = new short[numStates][];
+        for (int i=0; i<numStates; i++) {
+            DFA21_transition[i] = DFA.unpackEncodedString(DFA21_transitionS[i]);
+        }
+    }
+
+    class DFA21 extends DFA {
+
+        public DFA21(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 21;
+            this.eot = DFA21_eot;
+            this.eof = DFA21_eof;
+            this.min = DFA21_min;
+            this.max = DFA21_max;
+            this.accept = DFA21_accept;
+            this.special = DFA21_special;
+            this.transition = DFA21_transition;
+        }
+        public String getDescription() {
+            return "1:1: Tokens : ( 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 | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_ID | RULE_STRING | RULE_ML_COMMENT | RULE_SL_COMMENT | 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 LA21_0 = input.LA(1);
+
+                        s = -1;
+                        if ( (LA21_0=='i') ) {s = 1;}
+
+                        else if ( (LA21_0=='s') ) {s = 2;}
+
+                        else if ( (LA21_0=='e') ) {s = 3;}
+
+                        else if ( (LA21_0=='*') ) {s = 4;}
+
+                        else if ( (LA21_0=='n') ) {s = 5;}
+
+                        else if ( (LA21_0==';') ) {s = 6;}
+
+                        else if ( (LA21_0=='@') ) {s = 7;}
+
+                        else if ( (LA21_0=='(') ) {s = 8;}
+
+                        else if ( (LA21_0==',') ) {s = 9;}
+
+                        else if ( (LA21_0==')') ) {s = 10;}
+
+                        else if ( (LA21_0=='=') ) {s = 11;}
+
+                        else if ( (LA21_0=='#') ) {s = 12;}
+
+                        else if ( (LA21_0=='[') ) {s = 13;}
+
+                        else if ( (LA21_0==']') ) {s = 14;}
+
+                        else if ( (LA21_0=='+') ) {s = 15;}
+
+                        else if ( (LA21_0=='-') ) {s = 16;}
+
+                        else if ( (LA21_0=='/') ) {s = 17;}
+
+                        else if ( (LA21_0=='%') ) {s = 18;}
+
+                        else if ( (LA21_0=='<') ) {s = 19;}
+
+                        else if ( (LA21_0=='>') ) {s = 20;}
+
+                        else if ( (LA21_0=='|') ) {s = 21;}
+
+                        else if ( (LA21_0=='&') ) {s = 22;}
+
+                        else if ( (LA21_0=='!') ) {s = 23;}
+
+                        else if ( (LA21_0=='.') ) {s = 24;}
+
+                        else if ( (LA21_0=='?') ) {s = 25;}
+
+                        else if ( (LA21_0=='a') ) {s = 26;}
+
+                        else if ( (LA21_0==':') ) {s = 27;}
+
+                        else if ( (LA21_0=='{') ) {s = 28;}
+
+                        else if ( (LA21_0=='}') ) {s = 29;}
+
+                        else if ( (LA21_0=='d') ) {s = 30;}
+
+                        else if ( (LA21_0=='c') ) {s = 31;}
+
+                        else if ( (LA21_0=='f') ) {s = 32;}
+
+                        else if ( (LA21_0=='w') ) {s = 33;}
+
+                        else if ( (LA21_0=='v') ) {s = 34;}
+
+                        else if ( (LA21_0=='t') ) {s = 35;}
+
+                        else if ( (LA21_0=='r') ) {s = 36;}
+
+                        else if ( (LA21_0=='0') ) {s = 37;}
+
+                        else if ( ((LA21_0>='1' && LA21_0<='9')) ) {s = 38;}
+
+                        else if ( (LA21_0=='^') ) {s = 39;}
+
+                        else if ( (LA21_0=='$'||(LA21_0>='A' && LA21_0<='Z')||LA21_0=='_'||LA21_0=='b'||(LA21_0>='g' && LA21_0<='h')||(LA21_0>='j' && LA21_0<='m')||(LA21_0>='o' && LA21_0<='q')||LA21_0=='u'||(LA21_0>='x' && LA21_0<='z')) ) {s = 40;}
+
+                        else if ( (LA21_0=='\"') ) {s = 41;}
+
+                        else if ( (LA21_0=='\'') ) {s = 42;}
+
+                        else if ( ((LA21_0>='\t' && LA21_0<='\n')||LA21_0=='\r'||LA21_0==' ') ) {s = 43;}
+
+                        else if ( ((LA21_0>='\u0000' && LA21_0<='\b')||(LA21_0>='\u000B' && LA21_0<='\f')||(LA21_0>='\u000E' && LA21_0<='\u001F')||LA21_0=='\\'||LA21_0=='`'||(LA21_0>='~' && LA21_0<='\uFFFF')) ) {s = 44;}
+
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 21, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+ 
+
+}
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeParser.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeParser.java
new file mode 100644
index 0000000..e30de50
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/parser/antlr/internal/InternalOXtypeParser.java
@@ -0,0 +1,24135 @@
+package org.eclipse.osbp.xtext.oxtype.parser.antlr.internal;
+
+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.AbstractInternalAntlrParser;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+
+
+
+import org.antlr.runtime.*;
+import java.util.Stack;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.Map;
+import java.util.HashMap;
+@SuppressWarnings("all")
+public class InternalOXtypeParser extends AbstractInternalAntlrParser {
+    public static final String[] tokenNames = new String[] {
+        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_STRING", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_ID", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'import'", "'static'", "'extension'", "'*'", "'ns'", "';'", "'@'", "'('", "','", "')'", "'='", "'#'", "'['", "']'", "'+='", "'-='", "'*='", "'/='", "'%='", "'<'", "'>'", "'>='", "'||'", "'&&'", "'=='", "'!='", "'==='", "'!=='", "'instanceof'", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'+'", "'-'", "'**'", "'/'", "'%'", "'!'", "'as'", "'++'", "'--'", "'.'", "'::'", "'?.'", "'{'", "'}'", "'|'", "'if'", "'else'", "'switch'", "':'", "'default'", "'case'", "'for'", "'while'", "'do'", "'var'", "'val'", "'extends'", "'super'", "'new'", "'false'", "'true'", "'null'", "'typeof'", "'throw'", "'return'", "'try'", "'finally'", "'synchronized'", "'catch'", "'?'", "'&'"
+    };
+    public static final int RULE_HEX=5;
+    public static final int T__50=50;
+    public static final int T__19=19;
+    public static final int T__15=15;
+    public static final int T__59=59;
+    public static final int T__16=16;
+    public static final int T__17=17;
+    public static final int T__18=18;
+    public static final int T__55=55;
+    public static final int T__56=56;
+    public static final int T__13=13;
+    public static final int T__57=57;
+    public static final int T__14=14;
+    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__60=60;
+    public static final int T__61=61;
+    public static final int RULE_ID=8;
+    public static final int RULE_DECIMAL=7;
+    public static final int T__26=26;
+    public static final int T__27=27;
+    public static final int T__28=28;
+    public static final int RULE_INT=6;
+    public static final int T__29=29;
+    public static final int T__22=22;
+    public static final int T__66=66;
+    public static final int RULE_ML_COMMENT=9;
+    public static final int T__23=23;
+    public static final int T__67=67;
+    public static final int T__24=24;
+    public static final int T__68=68;
+    public static final int T__25=25;
+    public static final int T__69=69;
+    public static final int T__62=62;
+    public static final int T__63=63;
+    public static final int T__20=20;
+    public static final int T__64=64;
+    public static final int T__21=21;
+    public static final int T__65=65;
+    public static final int T__70=70;
+    public static final int T__71=71;
+    public static final int T__72=72;
+    public static final int RULE_STRING=4;
+    public static final int RULE_SL_COMMENT=10;
+    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 T__33=33;
+    public static final int T__77=77;
+    public static final int T__34=34;
+    public static final int T__78=78;
+    public static final int T__35=35;
+    public static final int T__79=79;
+    public static final int T__36=36;
+    public static final int T__73=73;
+    public static final int EOF=-1;
+    public static final int T__30=30;
+    public static final int T__74=74;
+    public static final int T__31=31;
+    public static final int T__75=75;
+    public static final int T__32=32;
+    public static final int T__76=76;
+    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 RULE_WS=11;
+    public static final int RULE_ANY_OTHER=12;
+    public static final int T__48=48;
+    public static final int T__49=49;
+    public static final int T__44=44;
+    public static final int T__88=88;
+    public static final int T__45=45;
+    public static final int T__46=46;
+    public static final int T__47=47;
+    public static final int T__40=40;
+    public static final int T__84=84;
+    public static final int T__41=41;
+    public static final int T__85=85;
+    public static final int T__42=42;
+    public static final int T__86=86;
+    public static final int T__43=43;
+    public static final int T__87=87;
+
+    // delegates
+    // delegators
+
+
+        public InternalOXtypeParser(TokenStream input) {
+            this(input, new RecognizerSharedState());
+        }
+        public InternalOXtypeParser(TokenStream input, RecognizerSharedState state) {
+            super(input, state);
+             
+        }
+        
+
+    public String[] getTokenNames() { return InternalOXtypeParser.tokenNames; }
+    public String getGrammarFileName() { return "InternalOXtype.g"; }
+
+
+
+     	private OXtypeGrammarAccess grammarAccess;
+
+        public InternalOXtypeParser(TokenStream input, OXtypeGrammarAccess grammarAccess) {
+            this(input);
+            this.grammarAccess = grammarAccess;
+            registerRules(grammarAccess.getGrammar());
+        }
+
+        @Override
+        protected String getFirstRuleName() {
+        	return "XImportDeclaration";
+       	}
+
+       	@Override
+       	protected OXtypeGrammarAccess getGrammarAccess() {
+       		return grammarAccess;
+       	}
+
+
+
+
+    // $ANTLR start "entryRuleXImportDeclaration"
+    // InternalOXtype.g:64:1: entryRuleXImportDeclaration returns [EObject current=null] : iv_ruleXImportDeclaration= ruleXImportDeclaration EOF ;
+    public final EObject entryRuleXImportDeclaration() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXImportDeclaration = null;
+
+
+        try {
+            // InternalOXtype.g:64:59: (iv_ruleXImportDeclaration= ruleXImportDeclaration EOF )
+            // InternalOXtype.g:65:2: iv_ruleXImportDeclaration= ruleXImportDeclaration EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXImportDeclarationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXImportDeclaration=ruleXImportDeclaration();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXImportDeclaration; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXImportDeclaration"
+
+
+    // $ANTLR start "ruleXImportDeclaration"
+    // InternalOXtype.g:71:1: ruleXImportDeclaration returns [EObject current=null] : ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? ) ;
+    public final EObject ruleXImportDeclaration() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token lv_static_2_0=null;
+        Token lv_extension_3_0=null;
+        Token lv_wildcard_5_0=null;
+        Token lv_fqnImport_9_0=null;
+        Token otherlv_11=null;
+        AntlrDatatypeRuleToken lv_memberName_6_0 = null;
+
+        AntlrDatatypeRuleToken lv_importedNamespace_8_0 = null;
+
+        AntlrDatatypeRuleToken lv_importedFullyQualifiedName_10_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:77:2: ( ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? ) )
+            // InternalOXtype.g:78:2: ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? )
+            {
+            // InternalOXtype.g:78:2: ( () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )? )
+            // InternalOXtype.g:79:3: () otherlv_1= 'import' ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) ) (otherlv_11= ';' )?
+            {
+            // InternalOXtype.g:79:3: ()
+            // InternalOXtype.g:80:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXImportDeclarationAccess().getOXImportDeclarationAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,13,FOLLOW_3); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXImportDeclarationAccess().getImportKeyword_1());
+              		
+            }
+            // InternalOXtype.g:90:3: ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) )
+            int alt3=4;
+            alt3 = dfa3.predict(input);
+            switch (alt3) {
+                case 1 :
+                    // InternalOXtype.g:91:4: ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) )
+                    {
+                    // InternalOXtype.g:91:4: ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) )
+                    // InternalOXtype.g:92:5: ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) )
+                    {
+                    // InternalOXtype.g:92:5: ( (lv_static_2_0= 'static' ) )
+                    // InternalOXtype.g:93:6: (lv_static_2_0= 'static' )
+                    {
+                    // InternalOXtype.g:93:6: (lv_static_2_0= 'static' )
+                    // InternalOXtype.g:94:7: lv_static_2_0= 'static'
+                    {
+                    lv_static_2_0=(Token)match(input,14,FOLLOW_4); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							newLeafNode(lv_static_2_0, grammarAccess.getXImportDeclarationAccess().getStaticStaticKeyword_2_0_0_0());
+                      						
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElement(grammarAccess.getXImportDeclarationRule());
+                      							}
+                      							setWithLastConsumed(current, "static", true, "static");
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:106:5: ( (lv_extension_3_0= 'extension' ) )?
+                    int alt1=2;
+                    int LA1_0 = input.LA(1);
+
+                    if ( (LA1_0==15) ) {
+                        alt1=1;
+                    }
+                    switch (alt1) {
+                        case 1 :
+                            // InternalOXtype.g:107:6: (lv_extension_3_0= 'extension' )
+                            {
+                            // InternalOXtype.g:107:6: (lv_extension_3_0= 'extension' )
+                            // InternalOXtype.g:108:7: lv_extension_3_0= 'extension'
+                            {
+                            lv_extension_3_0=(Token)match(input,15,FOLLOW_4); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							newLeafNode(lv_extension_3_0, grammarAccess.getXImportDeclarationAccess().getExtensionExtensionKeyword_2_0_1_0());
+                              						
+                            }
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElement(grammarAccess.getXImportDeclarationRule());
+                              							}
+                              							setWithLastConsumed(current, "extension", true, "extension");
+                              						
+                            }
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+                    // InternalOXtype.g:120:5: ( ( ruleQualifiedNameInStaticImport ) )
+                    // InternalOXtype.g:121:6: ( ruleQualifiedNameInStaticImport )
+                    {
+                    // InternalOXtype.g:121:6: ( ruleQualifiedNameInStaticImport )
+                    // InternalOXtype.g:122:7: ruleQualifiedNameInStaticImport
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElement(grammarAccess.getXImportDeclarationRule());
+                      							}
+                      						
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_5);
+                    ruleQualifiedNameInStaticImport();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:136:5: ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) )
+                    int alt2=2;
+                    int LA2_0 = input.LA(1);
+
+                    if ( (LA2_0==16) ) {
+                        alt2=1;
+                    }
+                    else if ( (LA2_0==RULE_ID) ) {
+                        alt2=2;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return current;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 2, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt2) {
+                        case 1 :
+                            // InternalOXtype.g:137:6: ( (lv_wildcard_5_0= '*' ) )
+                            {
+                            // InternalOXtype.g:137:6: ( (lv_wildcard_5_0= '*' ) )
+                            // InternalOXtype.g:138:7: (lv_wildcard_5_0= '*' )
+                            {
+                            // InternalOXtype.g:138:7: (lv_wildcard_5_0= '*' )
+                            // InternalOXtype.g:139:8: lv_wildcard_5_0= '*'
+                            {
+                            lv_wildcard_5_0=(Token)match(input,16,FOLLOW_6); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								newLeafNode(lv_wildcard_5_0, grammarAccess.getXImportDeclarationAccess().getWildcardAsteriskKeyword_2_0_3_0_0());
+                              							
+                            }
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElement(grammarAccess.getXImportDeclarationRule());
+                              								}
+                              								setWithLastConsumed(current, "wildcard", true, "*");
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:152:6: ( (lv_memberName_6_0= ruleValidID ) )
+                            {
+                            // InternalOXtype.g:152:6: ( (lv_memberName_6_0= ruleValidID ) )
+                            // InternalOXtype.g:153:7: (lv_memberName_6_0= ruleValidID )
+                            {
+                            // InternalOXtype.g:153:7: (lv_memberName_6_0= ruleValidID )
+                            // InternalOXtype.g:154:8: lv_memberName_6_0= ruleValidID
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								newCompositeNode(grammarAccess.getXImportDeclarationAccess().getMemberNameValidIDParserRuleCall_2_0_3_1_0());
+                              							
+                            }
+                            pushFollow(FOLLOW_6);
+                            lv_memberName_6_0=ruleValidID();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+                              								}
+                              								set(
+                              									current,
+                              									"memberName",
+                              									lv_memberName_6_0,
+                              									"org.eclipse.xtext.xbase.Xtype.ValidID");
+                              								afterParserOrEnumRuleCall();
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:174:4: ( ( ruleQualifiedName ) )
+                    {
+                    // InternalOXtype.g:174:4: ( ( ruleQualifiedName ) )
+                    // InternalOXtype.g:175:5: ( ruleQualifiedName )
+                    {
+                    // InternalOXtype.g:175:5: ( ruleQualifiedName )
+                    // InternalOXtype.g:176:6: ruleQualifiedName
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXImportDeclarationRule());
+                      						}
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedTypeJvmDeclaredTypeCrossReference_2_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_6);
+                    ruleQualifiedName();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:191:4: ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) )
+                    {
+                    // InternalOXtype.g:191:4: ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) )
+                    // InternalOXtype.g:192:5: (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard )
+                    {
+                    // InternalOXtype.g:192:5: (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard )
+                    // InternalOXtype.g:193:6: lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_6);
+                    lv_importedNamespace_8_0=ruleQualifiedNameWithWildcard();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+                      						}
+                      						set(
+                      							current,
+                      							"importedNamespace",
+                      							lv_importedNamespace_8_0,
+                      							"org.eclipse.xtext.xbase.Xtype.QualifiedNameWithWildcard");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:211:4: ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) )
+                    {
+                    // InternalOXtype.g:211:4: ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) )
+                    // InternalOXtype.g:212:5: ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) )
+                    {
+                    // InternalOXtype.g:212:5: ( (lv_fqnImport_9_0= 'ns' ) )
+                    // InternalOXtype.g:213:6: (lv_fqnImport_9_0= 'ns' )
+                    {
+                    // InternalOXtype.g:213:6: (lv_fqnImport_9_0= 'ns' )
+                    // InternalOXtype.g:214:7: lv_fqnImport_9_0= 'ns'
+                    {
+                    lv_fqnImport_9_0=(Token)match(input,17,FOLLOW_7); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							newLeafNode(lv_fqnImport_9_0, grammarAccess.getXImportDeclarationAccess().getFqnImportNsKeyword_2_3_0_0());
+                      						
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElement(grammarAccess.getXImportDeclarationRule());
+                      							}
+                      							setWithLastConsumed(current, "fqnImport", true, "ns");
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:226:5: ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) )
+                    // InternalOXtype.g:227:6: (lv_importedFullyQualifiedName_10_0= ruleQualifiedName )
+                    {
+                    // InternalOXtype.g:227:6: (lv_importedFullyQualifiedName_10_0= ruleQualifiedName )
+                    // InternalOXtype.g:228:7: lv_importedFullyQualifiedName_10_0= ruleQualifiedName
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXImportDeclarationAccess().getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_6);
+                    lv_importedFullyQualifiedName_10_0=ruleQualifiedName();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getXImportDeclarationRule());
+                      							}
+                      							set(
+                      								current,
+                      								"importedFullyQualifiedName",
+                      								lv_importedFullyQualifiedName_10_0,
+                      								"org.eclipse.xtext.xbase.Xbase.QualifiedName");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:247:3: (otherlv_11= ';' )?
+            int alt4=2;
+            int LA4_0 = input.LA(1);
+
+            if ( (LA4_0==18) ) {
+                alt4=1;
+            }
+            switch (alt4) {
+                case 1 :
+                    // InternalOXtype.g:248:4: otherlv_11= ';'
+                    {
+                    otherlv_11=(Token)match(input,18,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_11, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXImportDeclaration"
+
+
+    // $ANTLR start "entryRuleXAnnotation"
+    // InternalOXtype.g:257:1: entryRuleXAnnotation returns [EObject current=null] : iv_ruleXAnnotation= ruleXAnnotation EOF ;
+    public final EObject entryRuleXAnnotation() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAnnotation = null;
+
+
+        try {
+            // InternalOXtype.g:257:52: (iv_ruleXAnnotation= ruleXAnnotation EOF )
+            // InternalOXtype.g:258:2: iv_ruleXAnnotation= ruleXAnnotation EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAnnotationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAnnotation=ruleXAnnotation();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAnnotation; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAnnotation"
+
+
+    // $ANTLR start "ruleXAnnotation"
+    // InternalOXtype.g:264:1: ruleXAnnotation returns [EObject current=null] : ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? ) ;
+    public final EObject ruleXAnnotation() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token otherlv_8=null;
+        EObject lv_elementValuePairs_4_0 = null;
+
+        EObject lv_elementValuePairs_6_0 = null;
+
+        EObject lv_value_7_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:270:2: ( ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? ) )
+            // InternalOXtype.g:271:2: ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? )
+            {
+            // InternalOXtype.g:271:2: ( () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )? )
+            // InternalOXtype.g:272:3: () otherlv_1= '@' ( ( ruleQualifiedName ) ) ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )?
+            {
+            // InternalOXtype.g:272:3: ()
+            // InternalOXtype.g:273:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXAnnotationAccess().getXAnnotationAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,19,FOLLOW_7); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXAnnotationAccess().getCommercialAtKeyword_1());
+              		
+            }
+            // InternalOXtype.g:283:3: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:284:4: ( ruleQualifiedName )
+            {
+            // InternalOXtype.g:284:4: ( ruleQualifiedName )
+            // InternalOXtype.g:285:5: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElement(grammarAccess.getXAnnotationRule());
+              					}
+              				
+            }
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXAnnotationAccess().getAnnotationTypeJvmAnnotationTypeCrossReference_2_0());
+              				
+            }
+            pushFollow(FOLLOW_8);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:299:3: ( ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')' )?
+            int alt7=2;
+            int LA7_0 = input.LA(1);
+
+            if ( (LA7_0==20) && (synpred1_InternalOXtype())) {
+                alt7=1;
+            }
+            switch (alt7) {
+                case 1 :
+                    // InternalOXtype.g:300:4: ( ( '(' )=>otherlv_3= '(' ) ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )? otherlv_8= ')'
+                    {
+                    // InternalOXtype.g:300:4: ( ( '(' )=>otherlv_3= '(' )
+                    // InternalOXtype.g:301:5: ( '(' )=>otherlv_3= '('
+                    {
+                    otherlv_3=(Token)match(input,20,FOLLOW_9); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_3, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0());
+                      				
+                    }
+
+                    }
+
+                    // InternalOXtype.g:307:4: ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )?
+                    int alt6=3;
+                    alt6 = dfa6.predict(input);
+                    switch (alt6) {
+                        case 1 :
+                            // InternalOXtype.g:308:5: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* )
+                            {
+                            // InternalOXtype.g:308:5: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* )
+                            // InternalOXtype.g:309:6: ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )*
+                            {
+                            // InternalOXtype.g:309:6: ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) )
+                            // InternalOXtype.g:310:7: ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair )
+                            {
+                            // InternalOXtype.g:319:7: (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair )
+                            // InternalOXtype.g:320:8: lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_0_0());
+                              							
+                            }
+                            pushFollow(FOLLOW_10);
+                            lv_elementValuePairs_4_0=ruleXAnnotationElementValuePair();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+                              								}
+                              								add(
+                              									current,
+                              									"elementValuePairs",
+                              									lv_elementValuePairs_4_0,
+                              									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+                              								afterParserOrEnumRuleCall();
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:337:6: (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )*
+                            loop5:
+                            do {
+                                int alt5=2;
+                                int LA5_0 = input.LA(1);
+
+                                if ( (LA5_0==21) ) {
+                                    alt5=1;
+                                }
+
+
+                                switch (alt5) {
+                            	case 1 :
+                            	    // InternalOXtype.g:338:7: otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) )
+                            	    {
+                            	    otherlv_5=(Token)match(input,21,FOLLOW_7); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      							newLeafNode(otherlv_5, grammarAccess.getXAnnotationAccess().getCommaKeyword_3_1_0_1_0());
+                            	      						
+                            	    }
+                            	    // InternalOXtype.g:342:7: ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) )
+                            	    // InternalOXtype.g:343:8: ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair )
+                            	    {
+                            	    // InternalOXtype.g:352:8: (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair )
+                            	    // InternalOXtype.g:353:9: lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									newCompositeNode(grammarAccess.getXAnnotationAccess().getElementValuePairsXAnnotationElementValuePairParserRuleCall_3_1_0_1_1_0());
+                            	      								
+                            	    }
+                            	    pushFollow(FOLLOW_10);
+                            	    lv_elementValuePairs_6_0=ruleXAnnotationElementValuePair();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									if (current==null) {
+                            	      										current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+                            	      									}
+                            	      									add(
+                            	      										current,
+                            	      										"elementValuePairs",
+                            	      										lv_elementValuePairs_6_0,
+                            	      										"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValuePair");
+                            	      									afterParserOrEnumRuleCall();
+                            	      								
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop5;
+                                }
+                            } while (true);
+
+
+                            }
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:373:5: ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) )
+                            {
+                            // InternalOXtype.g:373:5: ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) )
+                            // InternalOXtype.g:374:6: (lv_value_7_0= ruleXAnnotationElementValueOrCommaList )
+                            {
+                            // InternalOXtype.g:374:6: (lv_value_7_0= ruleXAnnotationElementValueOrCommaList )
+                            // InternalOXtype.g:375:7: lv_value_7_0= ruleXAnnotationElementValueOrCommaList
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXAnnotationAccess().getValueXAnnotationElementValueOrCommaListParserRuleCall_3_1_1_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_11);
+                            lv_value_7_0=ruleXAnnotationElementValueOrCommaList();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXAnnotationRule());
+                              							}
+                              							set(
+                              								current,
+                              								"value",
+                              								lv_value_7_0,
+                              								"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValueOrCommaList");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+                    otherlv_8=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_8, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAnnotation"
+
+
+    // $ANTLR start "entryRuleXAnnotationElementValuePair"
+    // InternalOXtype.g:402:1: entryRuleXAnnotationElementValuePair returns [EObject current=null] : iv_ruleXAnnotationElementValuePair= ruleXAnnotationElementValuePair EOF ;
+    public final EObject entryRuleXAnnotationElementValuePair() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAnnotationElementValuePair = null;
+
+
+        try {
+            // InternalOXtype.g:402:68: (iv_ruleXAnnotationElementValuePair= ruleXAnnotationElementValuePair EOF )
+            // InternalOXtype.g:403:2: iv_ruleXAnnotationElementValuePair= ruleXAnnotationElementValuePair EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAnnotationElementValuePairRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAnnotationElementValuePair=ruleXAnnotationElementValuePair();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAnnotationElementValuePair; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAnnotationElementValuePair"
+
+
+    // $ANTLR start "ruleXAnnotationElementValuePair"
+    // InternalOXtype.g:409:1: ruleXAnnotationElementValuePair returns [EObject current=null] : ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) ) ;
+    public final EObject ruleXAnnotationElementValuePair() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        EObject lv_value_2_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:415:2: ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) ) )
+            // InternalOXtype.g:416:2: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) )
+            {
+            // InternalOXtype.g:416:2: ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) ) )
+            // InternalOXtype.g:417:3: ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) ) ( (lv_value_2_0= ruleXAnnotationElementValue ) )
+            {
+            // InternalOXtype.g:417:3: ( ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' ) )
+            // InternalOXtype.g:418:4: ( ( ( ( ruleValidID ) ) '=' ) )=> ( ( ( ruleValidID ) ) otherlv_1= '=' )
+            {
+            // InternalOXtype.g:427:4: ( ( ( ruleValidID ) ) otherlv_1= '=' )
+            // InternalOXtype.g:428:5: ( ( ruleValidID ) ) otherlv_1= '='
+            {
+            // InternalOXtype.g:428:5: ( ( ruleValidID ) )
+            // InternalOXtype.g:429:6: ( ruleValidID )
+            {
+            // InternalOXtype.g:429:6: ( ruleValidID )
+            // InternalOXtype.g:430:7: ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+
+              							if (current==null) {
+              								current = createModelElement(grammarAccess.getXAnnotationElementValuePairRule());
+              							}
+              						
+            }
+            if ( state.backtracking==0 ) {
+
+              							newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getElementJvmOperationCrossReference_0_0_0_0());
+              						
+            }
+            pushFollow(FOLLOW_12);
+            ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              							afterParserOrEnumRuleCall();
+              						
+            }
+
+            }
+
+
+            }
+
+            otherlv_1=(Token)match(input,23,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValuePairAccess().getEqualsSignKeyword_0_0_1());
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:450:3: ( (lv_value_2_0= ruleXAnnotationElementValue ) )
+            // InternalOXtype.g:451:4: (lv_value_2_0= ruleXAnnotationElementValue )
+            {
+            // InternalOXtype.g:451:4: (lv_value_2_0= ruleXAnnotationElementValue )
+            // InternalOXtype.g:452:5: lv_value_2_0= ruleXAnnotationElementValue
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXAnnotationElementValuePairAccess().getValueXAnnotationElementValueParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_value_2_0=ruleXAnnotationElementValue();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXAnnotationElementValuePairRule());
+              					}
+              					set(
+              						current,
+              						"value",
+              						lv_value_2_0,
+              						"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationElementValue");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAnnotationElementValuePair"
+
+
+    // $ANTLR start "entryRuleXAnnotationElementValueOrCommaList"
+    // InternalOXtype.g:473:1: entryRuleXAnnotationElementValueOrCommaList returns [EObject current=null] : iv_ruleXAnnotationElementValueOrCommaList= ruleXAnnotationElementValueOrCommaList EOF ;
+    public final EObject entryRuleXAnnotationElementValueOrCommaList() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAnnotationElementValueOrCommaList = null;
+
+
+        try {
+            // InternalOXtype.g:473:75: (iv_ruleXAnnotationElementValueOrCommaList= ruleXAnnotationElementValueOrCommaList EOF )
+            // InternalOXtype.g:474:2: iv_ruleXAnnotationElementValueOrCommaList= ruleXAnnotationElementValueOrCommaList EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAnnotationElementValueOrCommaList=ruleXAnnotationElementValueOrCommaList();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAnnotationElementValueOrCommaList; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAnnotationElementValueOrCommaList"
+
+
+    // $ANTLR start "ruleXAnnotationElementValueOrCommaList"
+    // InternalOXtype.g:480:1: ruleXAnnotationElementValueOrCommaList returns [EObject current=null] : ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) ) ;
+    public final EObject ruleXAnnotationElementValueOrCommaList() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        Token otherlv_9=null;
+        EObject lv_elements_3_0 = null;
+
+        EObject lv_elements_5_0 = null;
+
+        EObject this_XAnnotationOrExpression_7 = null;
+
+        EObject lv_elements_10_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:486:2: ( ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) ) )
+            // InternalOXtype.g:487:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) )
+            {
+            // InternalOXtype.g:487:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) )
+            int alt12=2;
+            alt12 = dfa12.predict(input);
+            switch (alt12) {
+                case 1 :
+                    // InternalOXtype.g:488:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+                    {
+                    // InternalOXtype.g:488:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+                    // InternalOXtype.g:489:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']'
+                    {
+                    // InternalOXtype.g:489:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) )
+                    // InternalOXtype.g:490:5: ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' )
+                    {
+                    // InternalOXtype.g:497:5: ( () otherlv_1= '#' otherlv_2= '[' )
+                    // InternalOXtype.g:498:6: () otherlv_1= '#' otherlv_2= '['
+                    {
+                    // InternalOXtype.g:498:6: ()
+                    // InternalOXtype.g:499:7: 
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							current = forceCreateModelElement(
+                      								grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralAction_0_0_0_0(),
+                      								current);
+                      						
+                    }
+
+                    }
+
+                    otherlv_1=(Token)match(input,24,FOLLOW_14); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getNumberSignKeyword_0_0_0_1());
+                      					
+                    }
+                    otherlv_2=(Token)match(input,25,FOLLOW_15); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getLeftSquareBracketKeyword_0_0_0_2());
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:515:4: ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )?
+                    int alt9=2;
+                    int LA9_0 = input.LA(1);
+
+                    if ( ((LA9_0>=RULE_STRING && LA9_0<=RULE_ID)||(LA9_0>=13 && LA9_0<=15)||(LA9_0>=19 && LA9_0<=20)||(LA9_0>=24 && LA9_0<=25)||LA9_0==32||(LA9_0>=48 && LA9_0<=49)||LA9_0==53||LA9_0==60||LA9_0==63||LA9_0==65||(LA9_0>=69 && LA9_0<=71)||(LA9_0>=74 && LA9_0<=83)||LA9_0==85) ) {
+                        alt9=1;
+                    }
+                    switch (alt9) {
+                        case 1 :
+                            // InternalOXtype.g:516:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+                            {
+                            // InternalOXtype.g:516:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) )
+                            // InternalOXtype.g:517:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+                            {
+                            // InternalOXtype.g:517:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+                            // InternalOXtype.g:518:7: lv_elements_3_0= ruleXAnnotationOrExpression
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_16);
+                            lv_elements_3_0=ruleXAnnotationOrExpression();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+                              							}
+                              							add(
+                              								current,
+                              								"elements",
+                              								lv_elements_3_0,
+                              								"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:535:5: (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+                            loop8:
+                            do {
+                                int alt8=2;
+                                int LA8_0 = input.LA(1);
+
+                                if ( (LA8_0==21) ) {
+                                    alt8=1;
+                                }
+
+
+                                switch (alt8) {
+                            	case 1 :
+                            	    // InternalOXtype.g:536:6: otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+                            	    {
+                            	    otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      						newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_0_1_1_0());
+                            	      					
+                            	    }
+                            	    // InternalOXtype.g:540:6: ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+                            	    // InternalOXtype.g:541:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+                            	    {
+                            	    // InternalOXtype.g:541:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+                            	    // InternalOXtype.g:542:8: lv_elements_5_0= ruleXAnnotationOrExpression
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+                            	      							
+                            	    }
+                            	    pushFollow(FOLLOW_16);
+                            	    lv_elements_5_0=ruleXAnnotationOrExpression();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								if (current==null) {
+                            	      									current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+                            	      								}
+                            	      								add(
+                            	      									current,
+                            	      									"elements",
+                            	      									lv_elements_5_0,
+                            	      									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+                            	      								afterParserOrEnumRuleCall();
+                            	      							
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop8;
+                                }
+                            } while (true);
+
+
+                            }
+                            break;
+
+                    }
+
+                    otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getRightSquareBracketKeyword_0_2());
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:567:3: (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? )
+                    {
+                    // InternalOXtype.g:567:3: (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? )
+                    // InternalOXtype.g:568:4: this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )?
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXAnnotationOrExpressionParserRuleCall_1_0());
+                      			
+                    }
+                    pushFollow(FOLLOW_17);
+                    this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current = this_XAnnotationOrExpression_7;
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+                    // InternalOXtype.g:576:4: ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )?
+                    int alt11=2;
+                    int LA11_0 = input.LA(1);
+
+                    if ( (LA11_0==21) ) {
+                        alt11=1;
+                    }
+                    switch (alt11) {
+                        case 1 :
+                            // InternalOXtype.g:577:5: () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+
+                            {
+                            // InternalOXtype.g:577:5: ()
+                            // InternalOXtype.g:578:6: 
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              						current = forceCreateModelElementAndAdd(
+                              							grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0(),
+                              							current);
+                              					
+                            }
+
+                            }
+
+                            // InternalOXtype.g:584:5: (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+
+                            int cnt10=0;
+                            loop10:
+                            do {
+                                int alt10=2;
+                                int LA10_0 = input.LA(1);
+
+                                if ( (LA10_0==21) ) {
+                                    alt10=1;
+                                }
+
+
+                                switch (alt10) {
+                            	case 1 :
+                            	    // InternalOXtype.g:585:6: otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) )
+                            	    {
+                            	    otherlv_9=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      						newLeafNode(otherlv_9, grammarAccess.getXAnnotationElementValueOrCommaListAccess().getCommaKeyword_1_1_1_0());
+                            	      					
+                            	    }
+                            	    // InternalOXtype.g:589:6: ( (lv_elements_10_0= ruleXAnnotationOrExpression ) )
+                            	    // InternalOXtype.g:590:7: (lv_elements_10_0= ruleXAnnotationOrExpression )
+                            	    {
+                            	    // InternalOXtype.g:590:7: (lv_elements_10_0= ruleXAnnotationOrExpression )
+                            	    // InternalOXtype.g:591:8: lv_elements_10_0= ruleXAnnotationOrExpression
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								newCompositeNode(grammarAccess.getXAnnotationElementValueOrCommaListAccess().getElementsXAnnotationOrExpressionParserRuleCall_1_1_1_1_0());
+                            	      							
+                            	    }
+                            	    pushFollow(FOLLOW_17);
+                            	    lv_elements_10_0=ruleXAnnotationOrExpression();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								if (current==null) {
+                            	      									current = createModelElementForParent(grammarAccess.getXAnnotationElementValueOrCommaListRule());
+                            	      								}
+                            	      								add(
+                            	      									current,
+                            	      									"elements",
+                            	      									lv_elements_10_0,
+                            	      									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+                            	      								afterParserOrEnumRuleCall();
+                            	      							
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    if ( cnt10 >= 1 ) break loop10;
+                            	    if (state.backtracking>0) {state.failed=true; return current;}
+                                        EarlyExitException eee =
+                                            new EarlyExitException(10, input);
+                                        throw eee;
+                                }
+                                cnt10++;
+                            } while (true);
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAnnotationElementValueOrCommaList"
+
+
+    // $ANTLR start "entryRuleXAnnotationElementValue"
+    // InternalOXtype.g:615:1: entryRuleXAnnotationElementValue returns [EObject current=null] : iv_ruleXAnnotationElementValue= ruleXAnnotationElementValue EOF ;
+    public final EObject entryRuleXAnnotationElementValue() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAnnotationElementValue = null;
+
+
+        try {
+            // InternalOXtype.g:615:64: (iv_ruleXAnnotationElementValue= ruleXAnnotationElementValue EOF )
+            // InternalOXtype.g:616:2: iv_ruleXAnnotationElementValue= ruleXAnnotationElementValue EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAnnotationElementValueRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAnnotationElementValue=ruleXAnnotationElementValue();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAnnotationElementValue; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAnnotationElementValue"
+
+
+    // $ANTLR start "ruleXAnnotationElementValue"
+    // InternalOXtype.g:622:1: ruleXAnnotationElementValue returns [EObject current=null] : ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ) ;
+    public final EObject ruleXAnnotationElementValue() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_elements_3_0 = null;
+
+        EObject lv_elements_5_0 = null;
+
+        EObject this_XAnnotationOrExpression_7 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:628:2: ( ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ) )
+            // InternalOXtype.g:629:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression )
+            {
+            // InternalOXtype.g:629:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression )
+            int alt15=2;
+            alt15 = dfa15.predict(input);
+            switch (alt15) {
+                case 1 :
+                    // InternalOXtype.g:630:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+                    {
+                    // InternalOXtype.g:630:3: ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' )
+                    // InternalOXtype.g:631:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']'
+                    {
+                    // InternalOXtype.g:631:4: ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) )
+                    // InternalOXtype.g:632:5: ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' )
+                    {
+                    // InternalOXtype.g:639:5: ( () otherlv_1= '#' otherlv_2= '[' )
+                    // InternalOXtype.g:640:6: () otherlv_1= '#' otherlv_2= '['
+                    {
+                    // InternalOXtype.g:640:6: ()
+                    // InternalOXtype.g:641:7: 
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							current = forceCreateModelElement(
+                      								grammarAccess.getXAnnotationElementValueAccess().getXListLiteralAction_0_0_0_0(),
+                      								current);
+                      						
+                    }
+
+                    }
+
+                    otherlv_1=(Token)match(input,24,FOLLOW_14); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(otherlv_1, grammarAccess.getXAnnotationElementValueAccess().getNumberSignKeyword_0_0_0_1());
+                      					
+                    }
+                    otherlv_2=(Token)match(input,25,FOLLOW_15); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(otherlv_2, grammarAccess.getXAnnotationElementValueAccess().getLeftSquareBracketKeyword_0_0_0_2());
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:657:4: ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )?
+                    int alt14=2;
+                    int LA14_0 = input.LA(1);
+
+                    if ( ((LA14_0>=RULE_STRING && LA14_0<=RULE_ID)||(LA14_0>=13 && LA14_0<=15)||(LA14_0>=19 && LA14_0<=20)||(LA14_0>=24 && LA14_0<=25)||LA14_0==32||(LA14_0>=48 && LA14_0<=49)||LA14_0==53||LA14_0==60||LA14_0==63||LA14_0==65||(LA14_0>=69 && LA14_0<=71)||(LA14_0>=74 && LA14_0<=83)||LA14_0==85) ) {
+                        alt14=1;
+                    }
+                    switch (alt14) {
+                        case 1 :
+                            // InternalOXtype.g:658:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+                            {
+                            // InternalOXtype.g:658:5: ( (lv_elements_3_0= ruleXAnnotationOrExpression ) )
+                            // InternalOXtype.g:659:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+                            {
+                            // InternalOXtype.g:659:6: (lv_elements_3_0= ruleXAnnotationOrExpression )
+                            // InternalOXtype.g:660:7: lv_elements_3_0= ruleXAnnotationOrExpression
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_0_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_16);
+                            lv_elements_3_0=ruleXAnnotationOrExpression();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+                              							}
+                              							add(
+                              								current,
+                              								"elements",
+                              								lv_elements_3_0,
+                              								"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:677:5: (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )*
+                            loop13:
+                            do {
+                                int alt13=2;
+                                int LA13_0 = input.LA(1);
+
+                                if ( (LA13_0==21) ) {
+                                    alt13=1;
+                                }
+
+
+                                switch (alt13) {
+                            	case 1 :
+                            	    // InternalOXtype.g:678:6: otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+                            	    {
+                            	    otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      						newLeafNode(otherlv_4, grammarAccess.getXAnnotationElementValueAccess().getCommaKeyword_0_1_1_0());
+                            	      					
+                            	    }
+                            	    // InternalOXtype.g:682:6: ( (lv_elements_5_0= ruleXAnnotationOrExpression ) )
+                            	    // InternalOXtype.g:683:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+                            	    {
+                            	    // InternalOXtype.g:683:7: (lv_elements_5_0= ruleXAnnotationOrExpression )
+                            	    // InternalOXtype.g:684:8: lv_elements_5_0= ruleXAnnotationOrExpression
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getElementsXAnnotationOrExpressionParserRuleCall_0_1_1_1_0());
+                            	      							
+                            	    }
+                            	    pushFollow(FOLLOW_16);
+                            	    lv_elements_5_0=ruleXAnnotationOrExpression();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								if (current==null) {
+                            	      									current = createModelElementForParent(grammarAccess.getXAnnotationElementValueRule());
+                            	      								}
+                            	      								add(
+                            	      									current,
+                            	      									"elements",
+                            	      									lv_elements_5_0,
+                            	      									"org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations.XAnnotationOrExpression");
+                            	      								afterParserOrEnumRuleCall();
+                            	      							
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop13;
+                                }
+                            } while (true);
+
+
+                            }
+                            break;
+
+                    }
+
+                    otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_6, grammarAccess.getXAnnotationElementValueAccess().getRightSquareBracketKeyword_0_2());
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:709:3: this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXAnnotationElementValueAccess().getXAnnotationOrExpressionParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XAnnotationOrExpression_7=ruleXAnnotationOrExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XAnnotationOrExpression_7;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAnnotationElementValue"
+
+
+    // $ANTLR start "entryRuleXAnnotationOrExpression"
+    // InternalOXtype.g:721:1: entryRuleXAnnotationOrExpression returns [EObject current=null] : iv_ruleXAnnotationOrExpression= ruleXAnnotationOrExpression EOF ;
+    public final EObject entryRuleXAnnotationOrExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAnnotationOrExpression = null;
+
+
+        try {
+            // InternalOXtype.g:721:64: (iv_ruleXAnnotationOrExpression= ruleXAnnotationOrExpression EOF )
+            // InternalOXtype.g:722:2: iv_ruleXAnnotationOrExpression= ruleXAnnotationOrExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAnnotationOrExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAnnotationOrExpression=ruleXAnnotationOrExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAnnotationOrExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAnnotationOrExpression"
+
+
+    // $ANTLR start "ruleXAnnotationOrExpression"
+    // InternalOXtype.g:728:1: ruleXAnnotationOrExpression returns [EObject current=null] : (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression ) ;
+    public final EObject ruleXAnnotationOrExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XAnnotation_0 = null;
+
+        EObject this_XExpression_1 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:734:2: ( (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression ) )
+            // InternalOXtype.g:735:2: (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression )
+            {
+            // InternalOXtype.g:735:2: (this_XAnnotation_0= ruleXAnnotation | this_XExpression_1= ruleXExpression )
+            int alt16=2;
+            int LA16_0 = input.LA(1);
+
+            if ( (LA16_0==19) ) {
+                alt16=1;
+            }
+            else if ( ((LA16_0>=RULE_STRING && LA16_0<=RULE_ID)||(LA16_0>=13 && LA16_0<=15)||LA16_0==20||(LA16_0>=24 && LA16_0<=25)||LA16_0==32||(LA16_0>=48 && LA16_0<=49)||LA16_0==53||LA16_0==60||LA16_0==63||LA16_0==65||(LA16_0>=69 && LA16_0<=71)||(LA16_0>=74 && LA16_0<=83)||LA16_0==85) ) {
+                alt16=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 16, 0, input);
+
+                throw nvae;
+            }
+            switch (alt16) {
+                case 1 :
+                    // InternalOXtype.g:736:3: this_XAnnotation_0= ruleXAnnotation
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXAnnotationParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XAnnotation_0=ruleXAnnotation();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XAnnotation_0;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:745:3: this_XExpression_1= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXAnnotationOrExpressionAccess().getXExpressionParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XExpression_1=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XExpression_1;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAnnotationOrExpression"
+
+
+    // $ANTLR start "entryRuleXExpression"
+    // InternalOXtype.g:757:1: entryRuleXExpression returns [EObject current=null] : iv_ruleXExpression= ruleXExpression EOF ;
+    public final EObject entryRuleXExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXExpression = null;
+
+
+        try {
+            // InternalOXtype.g:757:52: (iv_ruleXExpression= ruleXExpression EOF )
+            // InternalOXtype.g:758:2: iv_ruleXExpression= ruleXExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXExpression=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXExpression"
+
+
+    // $ANTLR start "ruleXExpression"
+    // InternalOXtype.g:764:1: ruleXExpression returns [EObject current=null] : this_XAssignment_0= ruleXAssignment ;
+    public final EObject ruleXExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XAssignment_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:770:2: (this_XAssignment_0= ruleXAssignment )
+            // InternalOXtype.g:771:2: this_XAssignment_0= ruleXAssignment
+            {
+            if ( state.backtracking==0 ) {
+
+              		newCompositeNode(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall());
+              	
+            }
+            pushFollow(FOLLOW_2);
+            this_XAssignment_0=ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              		current = this_XAssignment_0;
+              		afterParserOrEnumRuleCall();
+              	
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXExpression"
+
+
+    // $ANTLR start "entryRuleXAssignment"
+    // InternalOXtype.g:782:1: entryRuleXAssignment returns [EObject current=null] : iv_ruleXAssignment= ruleXAssignment EOF ;
+    public final EObject entryRuleXAssignment() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAssignment = null;
+
+
+        try {
+            // InternalOXtype.g:782:52: (iv_ruleXAssignment= ruleXAssignment EOF )
+            // InternalOXtype.g:783:2: iv_ruleXAssignment= ruleXAssignment EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAssignmentRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAssignment=ruleXAssignment();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAssignment; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAssignment"
+
+
+    // $ANTLR start "ruleXAssignment"
+    // InternalOXtype.g:789:1: ruleXAssignment returns [EObject current=null] : ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) ;
+    public final EObject ruleXAssignment() throws RecognitionException {
+        EObject current = null;
+
+        EObject lv_value_3_0 = null;
+
+        EObject this_XOrExpression_4 = null;
+
+        EObject lv_rightOperand_7_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:795:2: ( ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) ) )
+            // InternalOXtype.g:796:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) )
+            {
+            // InternalOXtype.g:796:2: ( ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) ) | (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? ) )
+            int alt18=2;
+            switch ( input.LA(1) ) {
+            case RULE_ID:
+                {
+                int LA18_1 = input.LA(2);
+
+                if ( (LA18_1==EOF||(LA18_1>=RULE_STRING && LA18_1<=RULE_ID)||(LA18_1>=13 && LA18_1<=16)||LA18_1==18||(LA18_1>=20 && LA18_1<=22)||(LA18_1>=24 && LA18_1<=61)||(LA18_1>=63 && LA18_1<=86)) ) {
+                    alt18=2;
+                }
+                else if ( (LA18_1==23) ) {
+                    alt18=1;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 18, 1, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 74:
+                {
+                int LA18_2 = input.LA(2);
+
+                if ( (LA18_2==EOF||(LA18_2>=RULE_STRING && LA18_2<=RULE_ID)||(LA18_2>=13 && LA18_2<=16)||LA18_2==18||(LA18_2>=20 && LA18_2<=22)||(LA18_2>=24 && LA18_2<=61)||(LA18_2>=63 && LA18_2<=86)) ) {
+                    alt18=2;
+                }
+                else if ( (LA18_2==23) ) {
+                    alt18=1;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 18, 2, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 14:
+                {
+                int LA18_3 = input.LA(2);
+
+                if ( (LA18_3==23) ) {
+                    alt18=1;
+                }
+                else if ( (LA18_3==EOF||(LA18_3>=RULE_STRING && LA18_3<=RULE_ID)||(LA18_3>=13 && LA18_3<=16)||LA18_3==18||(LA18_3>=20 && LA18_3<=22)||(LA18_3>=24 && LA18_3<=61)||(LA18_3>=63 && LA18_3<=86)) ) {
+                    alt18=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 18, 3, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 13:
+                {
+                int LA18_4 = input.LA(2);
+
+                if ( (LA18_4==23) ) {
+                    alt18=1;
+                }
+                else if ( (LA18_4==EOF||(LA18_4>=RULE_STRING && LA18_4<=RULE_ID)||(LA18_4>=13 && LA18_4<=16)||LA18_4==18||(LA18_4>=20 && LA18_4<=22)||(LA18_4>=24 && LA18_4<=61)||(LA18_4>=63 && LA18_4<=86)) ) {
+                    alt18=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 18, 4, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 15:
+                {
+                int LA18_5 = input.LA(2);
+
+                if ( (LA18_5==EOF||(LA18_5>=RULE_STRING && LA18_5<=RULE_ID)||(LA18_5>=13 && LA18_5<=16)||LA18_5==18||(LA18_5>=20 && LA18_5<=22)||(LA18_5>=24 && LA18_5<=61)||(LA18_5>=63 && LA18_5<=86)) ) {
+                    alt18=2;
+                }
+                else if ( (LA18_5==23) ) {
+                    alt18=1;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 18, 5, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case RULE_STRING:
+            case RULE_HEX:
+            case RULE_INT:
+            case RULE_DECIMAL:
+            case 20:
+            case 24:
+            case 25:
+            case 32:
+            case 48:
+            case 49:
+            case 53:
+            case 60:
+            case 63:
+            case 65:
+            case 69:
+            case 70:
+            case 71:
+            case 75:
+            case 76:
+            case 77:
+            case 78:
+            case 79:
+            case 80:
+            case 81:
+            case 82:
+            case 83:
+            case 85:
+                {
+                alt18=2;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 18, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt18) {
+                case 1 :
+                    // InternalOXtype.g:797:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) )
+                    {
+                    // InternalOXtype.g:797:3: ( () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) ) )
+                    // InternalOXtype.g:798:4: () ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ( (lv_value_3_0= ruleXAssignment ) )
+                    {
+                    // InternalOXtype.g:798:4: ()
+                    // InternalOXtype.g:799:5: 
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					current = forceCreateModelElement(
+                      						grammarAccess.getXAssignmentAccess().getXAssignmentAction_0_0(),
+                      						current);
+                      				
+                    }
+
+                    }
+
+                    // InternalOXtype.g:805:4: ( ( ruleFeatureCallID ) )
+                    // InternalOXtype.g:806:5: ( ruleFeatureCallID )
+                    {
+                    // InternalOXtype.g:806:5: ( ruleFeatureCallID )
+                    // InternalOXtype.g:807:6: ruleFeatureCallID
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXAssignmentRule());
+                      						}
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_12);
+                    ruleFeatureCallID();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getXAssignmentAccess().getOpSingleAssignParserRuleCall_0_2());
+                      			
+                    }
+                    pushFollow(FOLLOW_13);
+                    ruleOpSingleAssign();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+                    // InternalOXtype.g:828:4: ( (lv_value_3_0= ruleXAssignment ) )
+                    // InternalOXtype.g:829:5: (lv_value_3_0= ruleXAssignment )
+                    {
+                    // InternalOXtype.g:829:5: (lv_value_3_0= ruleXAssignment )
+                    // InternalOXtype.g:830:6: lv_value_3_0= ruleXAssignment
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXAssignmentAccess().getValueXAssignmentParserRuleCall_0_3_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_value_3_0=ruleXAssignment();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+                      						}
+                      						set(
+                      							current,
+                      							"value",
+                      							lv_value_3_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XAssignment");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:849:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? )
+                    {
+                    // InternalOXtype.g:849:3: (this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )? )
+                    // InternalOXtype.g:850:4: this_XOrExpression_4= ruleXOrExpression ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getXAssignmentAccess().getXOrExpressionParserRuleCall_1_0());
+                      			
+                    }
+                    pushFollow(FOLLOW_18);
+                    this_XOrExpression_4=ruleXOrExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current = this_XOrExpression_4;
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+                    // InternalOXtype.g:858:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?
+                    int alt17=2;
+                    alt17 = dfa17.predict(input);
+                    switch (alt17) {
+                        case 1 :
+                            // InternalOXtype.g:859:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) )
+                            {
+                            // InternalOXtype.g:859:5: ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) )
+                            // InternalOXtype.g:860:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) )
+                            {
+                            // InternalOXtype.g:870:6: ( () ( ( ruleOpMultiAssign ) ) )
+                            // InternalOXtype.g:871:7: () ( ( ruleOpMultiAssign ) )
+                            {
+                            // InternalOXtype.g:871:7: ()
+                            // InternalOXtype.g:872:8: 
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								current = forceCreateModelElementAndSet(
+                              									grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+                              									current);
+                              							
+                            }
+
+                            }
+
+                            // InternalOXtype.g:878:7: ( ( ruleOpMultiAssign ) )
+                            // InternalOXtype.g:879:8: ( ruleOpMultiAssign )
+                            {
+                            // InternalOXtype.g:879:8: ( ruleOpMultiAssign )
+                            // InternalOXtype.g:880:9: ruleOpMultiAssign
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              									if (current==null) {
+                              										current = createModelElement(grammarAccess.getXAssignmentRule());
+                              									}
+                              								
+                            }
+                            if ( state.backtracking==0 ) {
+
+                              									newCompositeNode(grammarAccess.getXAssignmentAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+                              								
+                            }
+                            pushFollow(FOLLOW_13);
+                            ruleOpMultiAssign();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              									afterParserOrEnumRuleCall();
+                              								
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:896:5: ( (lv_rightOperand_7_0= ruleXAssignment ) )
+                            // InternalOXtype.g:897:6: (lv_rightOperand_7_0= ruleXAssignment )
+                            {
+                            // InternalOXtype.g:897:6: (lv_rightOperand_7_0= ruleXAssignment )
+                            // InternalOXtype.g:898:7: lv_rightOperand_7_0= ruleXAssignment
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXAssignmentAccess().getRightOperandXAssignmentParserRuleCall_1_1_1_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_2);
+                            lv_rightOperand_7_0=ruleXAssignment();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXAssignmentRule());
+                              							}
+                              							set(
+                              								current,
+                              								"rightOperand",
+                              								lv_rightOperand_7_0,
+                              								"org.eclipse.xtext.xbase.Xbase.XAssignment");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAssignment"
+
+
+    // $ANTLR start "entryRuleOpSingleAssign"
+    // InternalOXtype.g:921:1: entryRuleOpSingleAssign returns [String current=null] : iv_ruleOpSingleAssign= ruleOpSingleAssign EOF ;
+    public final String entryRuleOpSingleAssign() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpSingleAssign = null;
+
+
+        try {
+            // InternalOXtype.g:921:54: (iv_ruleOpSingleAssign= ruleOpSingleAssign EOF )
+            // InternalOXtype.g:922:2: iv_ruleOpSingleAssign= ruleOpSingleAssign EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpSingleAssignRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpSingleAssign=ruleOpSingleAssign();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpSingleAssign.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpSingleAssign"
+
+
+    // $ANTLR start "ruleOpSingleAssign"
+    // InternalOXtype.g:928:1: ruleOpSingleAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '=' ;
+    public final AntlrDatatypeRuleToken ruleOpSingleAssign() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:934:2: (kw= '=' )
+            // InternalOXtype.g:935:2: kw= '='
+            {
+            kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              		current.merge(kw);
+              		newLeafNode(kw, grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword());
+              	
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpSingleAssign"
+
+
+    // $ANTLR start "entryRuleOpMultiAssign"
+    // InternalOXtype.g:943:1: entryRuleOpMultiAssign returns [String current=null] : iv_ruleOpMultiAssign= ruleOpMultiAssign EOF ;
+    public final String entryRuleOpMultiAssign() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpMultiAssign = null;
+
+
+        try {
+            // InternalOXtype.g:943:53: (iv_ruleOpMultiAssign= ruleOpMultiAssign EOF )
+            // InternalOXtype.g:944:2: iv_ruleOpMultiAssign= ruleOpMultiAssign EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpMultiAssignRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpMultiAssign=ruleOpMultiAssign();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpMultiAssign.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpMultiAssign"
+
+
+    // $ANTLR start "ruleOpMultiAssign"
+    // InternalOXtype.g:950:1: ruleOpMultiAssign returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) ;
+    public final AntlrDatatypeRuleToken ruleOpMultiAssign() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:956:2: ( (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) ) )
+            // InternalOXtype.g:957:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) )
+            {
+            // InternalOXtype.g:957:2: (kw= '+=' | kw= '-=' | kw= '*=' | kw= '/=' | kw= '%=' | (kw= '<' kw= '<' kw= '=' ) | (kw= '>' (kw= '>' )? kw= '>=' ) )
+            int alt20=7;
+            switch ( input.LA(1) ) {
+            case 27:
+                {
+                alt20=1;
+                }
+                break;
+            case 28:
+                {
+                alt20=2;
+                }
+                break;
+            case 29:
+                {
+                alt20=3;
+                }
+                break;
+            case 30:
+                {
+                alt20=4;
+                }
+                break;
+            case 31:
+                {
+                alt20=5;
+                }
+                break;
+            case 32:
+                {
+                alt20=6;
+                }
+                break;
+            case 33:
+                {
+                alt20=7;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 20, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt20) {
+                case 1 :
+                    // InternalOXtype.g:958:3: kw= '+='
+                    {
+                    kw=(Token)match(input,27,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPlusSignEqualsSignKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:964:3: kw= '-='
+                    {
+                    kw=(Token)match(input,28,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getHyphenMinusEqualsSignKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:970:3: kw= '*='
+                    {
+                    kw=(Token)match(input,29,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getAsteriskEqualsSignKeyword_2());
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:976:3: kw= '/='
+                    {
+                    kw=(Token)match(input,30,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getSolidusEqualsSignKeyword_3());
+                      		
+                    }
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:982:3: kw= '%='
+                    {
+                    kw=(Token)match(input,31,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getPercentSignEqualsSignKeyword_4());
+                      		
+                    }
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:988:3: (kw= '<' kw= '<' kw= '=' )
+                    {
+                    // InternalOXtype.g:988:3: (kw= '<' kw= '<' kw= '=' )
+                    // InternalOXtype.g:989:4: kw= '<' kw= '<' kw= '='
+                    {
+                    kw=(Token)match(input,32,FOLLOW_19); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_0());
+                      			
+                    }
+                    kw=(Token)match(input,32,FOLLOW_12); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getLessThanSignKeyword_5_1());
+                      			
+                    }
+                    kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getEqualsSignKeyword_5_2());
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:1006:3: (kw= '>' (kw= '>' )? kw= '>=' )
+                    {
+                    // InternalOXtype.g:1006:3: (kw= '>' (kw= '>' )? kw= '>=' )
+                    // InternalOXtype.g:1007:4: kw= '>' (kw= '>' )? kw= '>='
+                    {
+                    kw=(Token)match(input,33,FOLLOW_20); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_0());
+                      			
+                    }
+                    // InternalOXtype.g:1012:4: (kw= '>' )?
+                    int alt19=2;
+                    int LA19_0 = input.LA(1);
+
+                    if ( (LA19_0==33) ) {
+                        alt19=1;
+                    }
+                    switch (alt19) {
+                        case 1 :
+                            // InternalOXtype.g:1013:5: kw= '>'
+                            {
+                            kw=(Token)match(input,33,FOLLOW_21); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(kw);
+                              					newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignKeyword_6_1());
+                              				
+                            }
+
+                            }
+                            break;
+
+                    }
+
+                    kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpMultiAssignAccess().getGreaterThanSignEqualsSignKeyword_6_2());
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpMultiAssign"
+
+
+    // $ANTLR start "entryRuleXOrExpression"
+    // InternalOXtype.g:1029:1: entryRuleXOrExpression returns [EObject current=null] : iv_ruleXOrExpression= ruleXOrExpression EOF ;
+    public final EObject entryRuleXOrExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXOrExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1029:54: (iv_ruleXOrExpression= ruleXOrExpression EOF )
+            // InternalOXtype.g:1030:2: iv_ruleXOrExpression= ruleXOrExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXOrExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXOrExpression=ruleXOrExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXOrExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXOrExpression"
+
+
+    // $ANTLR start "ruleXOrExpression"
+    // InternalOXtype.g:1036:1: ruleXOrExpression returns [EObject current=null] : (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) ;
+    public final EObject ruleXOrExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XAndExpression_0 = null;
+
+        EObject lv_rightOperand_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1042:2: ( (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* ) )
+            // InternalOXtype.g:1043:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* )
+            {
+            // InternalOXtype.g:1043:2: (this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )* )
+            // InternalOXtype.g:1044:3: this_XAndExpression_0= ruleXAndExpression ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXOrExpressionAccess().getXAndExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_22);
+            this_XAndExpression_0=ruleXAndExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XAndExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1052:3: ( ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) ) )*
+            loop21:
+            do {
+                int alt21=2;
+                int LA21_0 = input.LA(1);
+
+                if ( (LA21_0==35) ) {
+                    int LA21_2 = input.LA(2);
+
+                    if ( (synpred8_InternalOXtype()) ) {
+                        alt21=1;
+                    }
+
+
+                }
+
+
+                switch (alt21) {
+            	case 1 :
+            	    // InternalOXtype.g:1053:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) ) ( (lv_rightOperand_3_0= ruleXAndExpression ) )
+            	    {
+            	    // InternalOXtype.g:1053:4: ( ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) ) )
+            	    // InternalOXtype.g:1054:5: ( ( () ( ( ruleOpOr ) ) ) )=> ( () ( ( ruleOpOr ) ) )
+            	    {
+            	    // InternalOXtype.g:1064:5: ( () ( ( ruleOpOr ) ) )
+            	    // InternalOXtype.g:1065:6: () ( ( ruleOpOr ) )
+            	    {
+            	    // InternalOXtype.g:1065:6: ()
+            	    // InternalOXtype.g:1066:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1072:6: ( ( ruleOpOr ) )
+            	    // InternalOXtype.g:1073:7: ( ruleOpOr )
+            	    {
+            	    // InternalOXtype.g:1073:7: ( ruleOpOr )
+            	    // InternalOXtype.g:1074:8: ruleOpOr
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								if (current==null) {
+            	      									current = createModelElement(grammarAccess.getXOrExpressionRule());
+            	      								}
+            	      							
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      								newCompositeNode(grammarAccess.getXOrExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+            	      							
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpOr();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      								afterParserOrEnumRuleCall();
+            	      							
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1090:4: ( (lv_rightOperand_3_0= ruleXAndExpression ) )
+            	    // InternalOXtype.g:1091:5: (lv_rightOperand_3_0= ruleXAndExpression )
+            	    {
+            	    // InternalOXtype.g:1091:5: (lv_rightOperand_3_0= ruleXAndExpression )
+            	    // InternalOXtype.g:1092:6: lv_rightOperand_3_0= ruleXAndExpression
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXOrExpressionAccess().getRightOperandXAndExpressionParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_22);
+            	    lv_rightOperand_3_0=ruleXAndExpression();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXOrExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"rightOperand",
+            	      							lv_rightOperand_3_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XAndExpression");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop21;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXOrExpression"
+
+
+    // $ANTLR start "entryRuleOpOr"
+    // InternalOXtype.g:1114:1: entryRuleOpOr returns [String current=null] : iv_ruleOpOr= ruleOpOr EOF ;
+    public final String entryRuleOpOr() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpOr = null;
+
+
+        try {
+            // InternalOXtype.g:1114:44: (iv_ruleOpOr= ruleOpOr EOF )
+            // InternalOXtype.g:1115:2: iv_ruleOpOr= ruleOpOr EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpOrRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpOr=ruleOpOr();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpOr.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpOr"
+
+
+    // $ANTLR start "ruleOpOr"
+    // InternalOXtype.g:1121:1: ruleOpOr returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '||' ;
+    public final AntlrDatatypeRuleToken ruleOpOr() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1127:2: (kw= '||' )
+            // InternalOXtype.g:1128:2: kw= '||'
+            {
+            kw=(Token)match(input,35,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              		current.merge(kw);
+              		newLeafNode(kw, grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword());
+              	
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpOr"
+
+
+    // $ANTLR start "entryRuleXAndExpression"
+    // InternalOXtype.g:1136:1: entryRuleXAndExpression returns [EObject current=null] : iv_ruleXAndExpression= ruleXAndExpression EOF ;
+    public final EObject entryRuleXAndExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAndExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1136:55: (iv_ruleXAndExpression= ruleXAndExpression EOF )
+            // InternalOXtype.g:1137:2: iv_ruleXAndExpression= ruleXAndExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAndExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAndExpression=ruleXAndExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAndExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAndExpression"
+
+
+    // $ANTLR start "ruleXAndExpression"
+    // InternalOXtype.g:1143:1: ruleXAndExpression returns [EObject current=null] : (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) ;
+    public final EObject ruleXAndExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XEqualityExpression_0 = null;
+
+        EObject lv_rightOperand_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1149:2: ( (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* ) )
+            // InternalOXtype.g:1150:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* )
+            {
+            // InternalOXtype.g:1150:2: (this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )* )
+            // InternalOXtype.g:1151:3: this_XEqualityExpression_0= ruleXEqualityExpression ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXAndExpressionAccess().getXEqualityExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_23);
+            this_XEqualityExpression_0=ruleXEqualityExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XEqualityExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1159:3: ( ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) ) )*
+            loop22:
+            do {
+                int alt22=2;
+                int LA22_0 = input.LA(1);
+
+                if ( (LA22_0==36) ) {
+                    int LA22_2 = input.LA(2);
+
+                    if ( (synpred9_InternalOXtype()) ) {
+                        alt22=1;
+                    }
+
+
+                }
+
+
+                switch (alt22) {
+            	case 1 :
+            	    // InternalOXtype.g:1160:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) ) ( (lv_rightOperand_3_0= ruleXEqualityExpression ) )
+            	    {
+            	    // InternalOXtype.g:1160:4: ( ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) ) )
+            	    // InternalOXtype.g:1161:5: ( ( () ( ( ruleOpAnd ) ) ) )=> ( () ( ( ruleOpAnd ) ) )
+            	    {
+            	    // InternalOXtype.g:1171:5: ( () ( ( ruleOpAnd ) ) )
+            	    // InternalOXtype.g:1172:6: () ( ( ruleOpAnd ) )
+            	    {
+            	    // InternalOXtype.g:1172:6: ()
+            	    // InternalOXtype.g:1173:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1179:6: ( ( ruleOpAnd ) )
+            	    // InternalOXtype.g:1180:7: ( ruleOpAnd )
+            	    {
+            	    // InternalOXtype.g:1180:7: ( ruleOpAnd )
+            	    // InternalOXtype.g:1181:8: ruleOpAnd
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								if (current==null) {
+            	      									current = createModelElement(grammarAccess.getXAndExpressionRule());
+            	      								}
+            	      							
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      								newCompositeNode(grammarAccess.getXAndExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+            	      							
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpAnd();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      								afterParserOrEnumRuleCall();
+            	      							
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1197:4: ( (lv_rightOperand_3_0= ruleXEqualityExpression ) )
+            	    // InternalOXtype.g:1198:5: (lv_rightOperand_3_0= ruleXEqualityExpression )
+            	    {
+            	    // InternalOXtype.g:1198:5: (lv_rightOperand_3_0= ruleXEqualityExpression )
+            	    // InternalOXtype.g:1199:6: lv_rightOperand_3_0= ruleXEqualityExpression
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXAndExpressionAccess().getRightOperandXEqualityExpressionParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_23);
+            	    lv_rightOperand_3_0=ruleXEqualityExpression();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXAndExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"rightOperand",
+            	      							lv_rightOperand_3_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XEqualityExpression");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop22;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAndExpression"
+
+
+    // $ANTLR start "entryRuleOpAnd"
+    // InternalOXtype.g:1221:1: entryRuleOpAnd returns [String current=null] : iv_ruleOpAnd= ruleOpAnd EOF ;
+    public final String entryRuleOpAnd() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpAnd = null;
+
+
+        try {
+            // InternalOXtype.g:1221:45: (iv_ruleOpAnd= ruleOpAnd EOF )
+            // InternalOXtype.g:1222:2: iv_ruleOpAnd= ruleOpAnd EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpAndRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpAnd=ruleOpAnd();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpAnd.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpAnd"
+
+
+    // $ANTLR start "ruleOpAnd"
+    // InternalOXtype.g:1228:1: ruleOpAnd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : kw= '&&' ;
+    public final AntlrDatatypeRuleToken ruleOpAnd() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1234:2: (kw= '&&' )
+            // InternalOXtype.g:1235:2: kw= '&&'
+            {
+            kw=(Token)match(input,36,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              		current.merge(kw);
+              		newLeafNode(kw, grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword());
+              	
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpAnd"
+
+
+    // $ANTLR start "entryRuleXEqualityExpression"
+    // InternalOXtype.g:1243:1: entryRuleXEqualityExpression returns [EObject current=null] : iv_ruleXEqualityExpression= ruleXEqualityExpression EOF ;
+    public final EObject entryRuleXEqualityExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXEqualityExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1243:60: (iv_ruleXEqualityExpression= ruleXEqualityExpression EOF )
+            // InternalOXtype.g:1244:2: iv_ruleXEqualityExpression= ruleXEqualityExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXEqualityExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXEqualityExpression=ruleXEqualityExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXEqualityExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXEqualityExpression"
+
+
+    // $ANTLR start "ruleXEqualityExpression"
+    // InternalOXtype.g:1250:1: ruleXEqualityExpression returns [EObject current=null] : (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) ;
+    public final EObject ruleXEqualityExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XRelationalExpression_0 = null;
+
+        EObject lv_rightOperand_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1256:2: ( (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* ) )
+            // InternalOXtype.g:1257:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* )
+            {
+            // InternalOXtype.g:1257:2: (this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )* )
+            // InternalOXtype.g:1258:3: this_XRelationalExpression_0= ruleXRelationalExpression ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getXRelationalExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_24);
+            this_XRelationalExpression_0=ruleXRelationalExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XRelationalExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1266:3: ( ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) ) )*
+            loop23:
+            do {
+                int alt23=2;
+                switch ( input.LA(1) ) {
+                case 37:
+                    {
+                    int LA23_2 = input.LA(2);
+
+                    if ( (synpred10_InternalOXtype()) ) {
+                        alt23=1;
+                    }
+
+
+                    }
+                    break;
+                case 38:
+                    {
+                    int LA23_3 = input.LA(2);
+
+                    if ( (synpred10_InternalOXtype()) ) {
+                        alt23=1;
+                    }
+
+
+                    }
+                    break;
+                case 39:
+                    {
+                    int LA23_4 = input.LA(2);
+
+                    if ( (synpred10_InternalOXtype()) ) {
+                        alt23=1;
+                    }
+
+
+                    }
+                    break;
+                case 40:
+                    {
+                    int LA23_5 = input.LA(2);
+
+                    if ( (synpred10_InternalOXtype()) ) {
+                        alt23=1;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt23) {
+            	case 1 :
+            	    // InternalOXtype.g:1267:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) ) ( (lv_rightOperand_3_0= ruleXRelationalExpression ) )
+            	    {
+            	    // InternalOXtype.g:1267:4: ( ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) ) )
+            	    // InternalOXtype.g:1268:5: ( ( () ( ( ruleOpEquality ) ) ) )=> ( () ( ( ruleOpEquality ) ) )
+            	    {
+            	    // InternalOXtype.g:1278:5: ( () ( ( ruleOpEquality ) ) )
+            	    // InternalOXtype.g:1279:6: () ( ( ruleOpEquality ) )
+            	    {
+            	    // InternalOXtype.g:1279:6: ()
+            	    // InternalOXtype.g:1280:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1286:6: ( ( ruleOpEquality ) )
+            	    // InternalOXtype.g:1287:7: ( ruleOpEquality )
+            	    {
+            	    // InternalOXtype.g:1287:7: ( ruleOpEquality )
+            	    // InternalOXtype.g:1288:8: ruleOpEquality
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								if (current==null) {
+            	      									current = createModelElement(grammarAccess.getXEqualityExpressionRule());
+            	      								}
+            	      							
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      								newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+            	      							
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpEquality();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      								afterParserOrEnumRuleCall();
+            	      							
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1304:4: ( (lv_rightOperand_3_0= ruleXRelationalExpression ) )
+            	    // InternalOXtype.g:1305:5: (lv_rightOperand_3_0= ruleXRelationalExpression )
+            	    {
+            	    // InternalOXtype.g:1305:5: (lv_rightOperand_3_0= ruleXRelationalExpression )
+            	    // InternalOXtype.g:1306:6: lv_rightOperand_3_0= ruleXRelationalExpression
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXEqualityExpressionAccess().getRightOperandXRelationalExpressionParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_24);
+            	    lv_rightOperand_3_0=ruleXRelationalExpression();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXEqualityExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"rightOperand",
+            	      							lv_rightOperand_3_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XRelationalExpression");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop23;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXEqualityExpression"
+
+
+    // $ANTLR start "entryRuleOpEquality"
+    // InternalOXtype.g:1328:1: entryRuleOpEquality returns [String current=null] : iv_ruleOpEquality= ruleOpEquality EOF ;
+    public final String entryRuleOpEquality() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpEquality = null;
+
+
+        try {
+            // InternalOXtype.g:1328:50: (iv_ruleOpEquality= ruleOpEquality EOF )
+            // InternalOXtype.g:1329:2: iv_ruleOpEquality= ruleOpEquality EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpEqualityRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpEquality=ruleOpEquality();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpEquality.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpEquality"
+
+
+    // $ANTLR start "ruleOpEquality"
+    // InternalOXtype.g:1335:1: ruleOpEquality returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) ;
+    public final AntlrDatatypeRuleToken ruleOpEquality() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1341:2: ( (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' ) )
+            // InternalOXtype.g:1342:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' )
+            {
+            // InternalOXtype.g:1342:2: (kw= '==' | kw= '!=' | kw= '===' | kw= '!==' )
+            int alt24=4;
+            switch ( input.LA(1) ) {
+            case 37:
+                {
+                alt24=1;
+                }
+                break;
+            case 38:
+                {
+                alt24=2;
+                }
+                break;
+            case 39:
+                {
+                alt24=3;
+                }
+                break;
+            case 40:
+                {
+                alt24=4;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 24, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt24) {
+                case 1 :
+                    // InternalOXtype.g:1343:3: kw= '=='
+                    {
+                    kw=(Token)match(input,37,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:1349:3: kw= '!='
+                    {
+                    kw=(Token)match(input,38,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:1355:3: kw= '==='
+                    {
+                    kw=(Token)match(input,39,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getEqualsSignEqualsSignEqualsSignKeyword_2());
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:1361:3: kw= '!=='
+                    {
+                    kw=(Token)match(input,40,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpEqualityAccess().getExclamationMarkEqualsSignEqualsSignKeyword_3());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpEquality"
+
+
+    // $ANTLR start "entryRuleXRelationalExpression"
+    // InternalOXtype.g:1370:1: entryRuleXRelationalExpression returns [EObject current=null] : iv_ruleXRelationalExpression= ruleXRelationalExpression EOF ;
+    public final EObject entryRuleXRelationalExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXRelationalExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1370:62: (iv_ruleXRelationalExpression= ruleXRelationalExpression EOF )
+            // InternalOXtype.g:1371:2: iv_ruleXRelationalExpression= ruleXRelationalExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXRelationalExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXRelationalExpression=ruleXRelationalExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXRelationalExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXRelationalExpression"
+
+
+    // $ANTLR start "ruleXRelationalExpression"
+    // InternalOXtype.g:1377:1: ruleXRelationalExpression returns [EObject current=null] : (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) ;
+    public final EObject ruleXRelationalExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_2=null;
+        EObject this_XOtherOperatorExpression_0 = null;
+
+        EObject lv_type_3_0 = null;
+
+        EObject lv_rightOperand_6_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1383:2: ( (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* ) )
+            // InternalOXtype.g:1384:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* )
+            {
+            // InternalOXtype.g:1384:2: (this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )* )
+            // InternalOXtype.g:1385:3: this_XOtherOperatorExpression_0= ruleXOtherOperatorExpression ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getXOtherOperatorExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_25);
+            this_XOtherOperatorExpression_0=ruleXOtherOperatorExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XOtherOperatorExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1393:3: ( ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) ) | ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) ) )*
+            loop25:
+            do {
+                int alt25=3;
+                switch ( input.LA(1) ) {
+                case 32:
+                    {
+                    int LA25_2 = input.LA(2);
+
+                    if ( (synpred12_InternalOXtype()) ) {
+                        alt25=2;
+                    }
+
+
+                    }
+                    break;
+                case 33:
+                    {
+                    int LA25_3 = input.LA(2);
+
+                    if ( (synpred12_InternalOXtype()) ) {
+                        alt25=2;
+                    }
+
+
+                    }
+                    break;
+                case 41:
+                    {
+                    int LA25_4 = input.LA(2);
+
+                    if ( (synpred11_InternalOXtype()) ) {
+                        alt25=1;
+                    }
+
+
+                    }
+                    break;
+                case 34:
+                    {
+                    int LA25_5 = input.LA(2);
+
+                    if ( (synpred12_InternalOXtype()) ) {
+                        alt25=2;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt25) {
+            	case 1 :
+            	    // InternalOXtype.g:1394:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )
+            	    {
+            	    // InternalOXtype.g:1394:4: ( ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )
+            	    // InternalOXtype.g:1395:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) )
+            	    {
+            	    // InternalOXtype.g:1395:5: ( ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' ) )
+            	    // InternalOXtype.g:1396:6: ( ( () 'instanceof' ) )=> ( () otherlv_2= 'instanceof' )
+            	    {
+            	    // InternalOXtype.g:1402:6: ( () otherlv_2= 'instanceof' )
+            	    // InternalOXtype.g:1403:7: () otherlv_2= 'instanceof'
+            	    {
+            	    // InternalOXtype.g:1403:7: ()
+            	    // InternalOXtype.g:1404:8: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								current = forceCreateModelElementAndSet(
+            	      									grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0(),
+            	      									current);
+            	      							
+            	    }
+
+            	    }
+
+            	    otherlv_2=(Token)match(input,41,FOLLOW_26); if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      							newLeafNode(otherlv_2, grammarAccess.getXRelationalExpressionAccess().getInstanceofKeyword_1_0_0_0_1());
+            	      						
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1416:5: ( (lv_type_3_0= ruleJvmTypeReference ) )
+            	    // InternalOXtype.g:1417:6: (lv_type_3_0= ruleJvmTypeReference )
+            	    {
+            	    // InternalOXtype.g:1417:6: (lv_type_3_0= ruleJvmTypeReference )
+            	    // InternalOXtype.g:1418:7: lv_type_3_0= ruleJvmTypeReference
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_0_1_0());
+            	      						
+            	    }
+            	    pushFollow(FOLLOW_25);
+            	    lv_type_3_0=ruleJvmTypeReference();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      							if (current==null) {
+            	      								current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+            	      							}
+            	      							set(
+            	      								current,
+            	      								"type",
+            	      								lv_type_3_0,
+            	      								"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+            	      							afterParserOrEnumRuleCall();
+            	      						
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+            	case 2 :
+            	    // InternalOXtype.g:1437:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) )
+            	    {
+            	    // InternalOXtype.g:1437:4: ( ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) ) )
+            	    // InternalOXtype.g:1438:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) ) ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) )
+            	    {
+            	    // InternalOXtype.g:1438:5: ( ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) ) )
+            	    // InternalOXtype.g:1439:6: ( ( () ( ( ruleOpCompare ) ) ) )=> ( () ( ( ruleOpCompare ) ) )
+            	    {
+            	    // InternalOXtype.g:1449:6: ( () ( ( ruleOpCompare ) ) )
+            	    // InternalOXtype.g:1450:7: () ( ( ruleOpCompare ) )
+            	    {
+            	    // InternalOXtype.g:1450:7: ()
+            	    // InternalOXtype.g:1451:8: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								current = forceCreateModelElementAndSet(
+            	      									grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0(),
+            	      									current);
+            	      							
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1457:7: ( ( ruleOpCompare ) )
+            	    // InternalOXtype.g:1458:8: ( ruleOpCompare )
+            	    {
+            	    // InternalOXtype.g:1458:8: ( ruleOpCompare )
+            	    // InternalOXtype.g:1459:9: ruleOpCompare
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      									if (current==null) {
+            	      										current = createModelElement(grammarAccess.getXRelationalExpressionRule());
+            	      									}
+            	      								
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      									newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_0_0_1_0());
+            	      								
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpCompare();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      									afterParserOrEnumRuleCall();
+            	      								
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1475:5: ( (lv_rightOperand_6_0= ruleXOtherOperatorExpression ) )
+            	    // InternalOXtype.g:1476:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression )
+            	    {
+            	    // InternalOXtype.g:1476:6: (lv_rightOperand_6_0= ruleXOtherOperatorExpression )
+            	    // InternalOXtype.g:1477:7: lv_rightOperand_6_0= ruleXOtherOperatorExpression
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							newCompositeNode(grammarAccess.getXRelationalExpressionAccess().getRightOperandXOtherOperatorExpressionParserRuleCall_1_1_1_0());
+            	      						
+            	    }
+            	    pushFollow(FOLLOW_25);
+            	    lv_rightOperand_6_0=ruleXOtherOperatorExpression();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      							if (current==null) {
+            	      								current = createModelElementForParent(grammarAccess.getXRelationalExpressionRule());
+            	      							}
+            	      							set(
+            	      								current,
+            	      								"rightOperand",
+            	      								lv_rightOperand_6_0,
+            	      								"org.eclipse.xtext.xbase.Xbase.XOtherOperatorExpression");
+            	      							afterParserOrEnumRuleCall();
+            	      						
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop25;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXRelationalExpression"
+
+
+    // $ANTLR start "entryRuleOpCompare"
+    // InternalOXtype.g:1500:1: entryRuleOpCompare returns [String current=null] : iv_ruleOpCompare= ruleOpCompare EOF ;
+    public final String entryRuleOpCompare() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpCompare = null;
+
+
+        try {
+            // InternalOXtype.g:1500:49: (iv_ruleOpCompare= ruleOpCompare EOF )
+            // InternalOXtype.g:1501:2: iv_ruleOpCompare= ruleOpCompare EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpCompareRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpCompare=ruleOpCompare();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpCompare.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpCompare"
+
+
+    // $ANTLR start "ruleOpCompare"
+    // InternalOXtype.g:1507:1: ruleOpCompare returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) ;
+    public final AntlrDatatypeRuleToken ruleOpCompare() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1513:2: ( (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' ) )
+            // InternalOXtype.g:1514:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' )
+            {
+            // InternalOXtype.g:1514:2: (kw= '>=' | (kw= '<' kw= '=' ) | kw= '>' | kw= '<' )
+            int alt26=4;
+            switch ( input.LA(1) ) {
+            case 34:
+                {
+                alt26=1;
+                }
+                break;
+            case 32:
+                {
+                int LA26_2 = input.LA(2);
+
+                if ( (LA26_2==EOF||(LA26_2>=RULE_STRING && LA26_2<=RULE_ID)||(LA26_2>=13 && LA26_2<=15)||LA26_2==20||(LA26_2>=24 && LA26_2<=25)||LA26_2==32||(LA26_2>=48 && LA26_2<=49)||LA26_2==53||LA26_2==60||LA26_2==63||LA26_2==65||(LA26_2>=69 && LA26_2<=71)||(LA26_2>=74 && LA26_2<=83)||LA26_2==85) ) {
+                    alt26=4;
+                }
+                else if ( (LA26_2==23) ) {
+                    alt26=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 26, 2, input);
+
+                    throw nvae;
+                }
+                }
+                break;
+            case 33:
+                {
+                alt26=3;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 26, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt26) {
+                case 1 :
+                    // InternalOXtype.g:1515:3: kw= '>='
+                    {
+                    kw=(Token)match(input,34,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignEqualsSignKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:1521:3: (kw= '<' kw= '=' )
+                    {
+                    // InternalOXtype.g:1521:3: (kw= '<' kw= '=' )
+                    // InternalOXtype.g:1522:4: kw= '<' kw= '='
+                    {
+                    kw=(Token)match(input,32,FOLLOW_12); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_1_0());
+                      			
+                    }
+                    kw=(Token)match(input,23,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpCompareAccess().getEqualsSignKeyword_1_1());
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:1534:3: kw= '>'
+                    {
+                    kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpCompareAccess().getGreaterThanSignKeyword_2());
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:1540:3: kw= '<'
+                    {
+                    kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpCompareAccess().getLessThanSignKeyword_3());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpCompare"
+
+
+    // $ANTLR start "entryRuleXOtherOperatorExpression"
+    // InternalOXtype.g:1549:1: entryRuleXOtherOperatorExpression returns [EObject current=null] : iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF ;
+    public final EObject entryRuleXOtherOperatorExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXOtherOperatorExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1549:65: (iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF )
+            // InternalOXtype.g:1550:2: iv_ruleXOtherOperatorExpression= ruleXOtherOperatorExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXOtherOperatorExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXOtherOperatorExpression=ruleXOtherOperatorExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXOtherOperatorExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXOtherOperatorExpression"
+
+
+    // $ANTLR start "ruleXOtherOperatorExpression"
+    // InternalOXtype.g:1556:1: ruleXOtherOperatorExpression returns [EObject current=null] : (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) ;
+    public final EObject ruleXOtherOperatorExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XAdditiveExpression_0 = null;
+
+        EObject lv_rightOperand_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1562:2: ( (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* ) )
+            // InternalOXtype.g:1563:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* )
+            {
+            // InternalOXtype.g:1563:2: (this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )* )
+            // InternalOXtype.g:1564:3: this_XAdditiveExpression_0= ruleXAdditiveExpression ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getXAdditiveExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_27);
+            this_XAdditiveExpression_0=ruleXAdditiveExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XAdditiveExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1572:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*
+            loop27:
+            do {
+                int alt27=2;
+                alt27 = dfa27.predict(input);
+                switch (alt27) {
+            	case 1 :
+            	    // InternalOXtype.g:1573:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) )
+            	    {
+            	    // InternalOXtype.g:1573:4: ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) )
+            	    // InternalOXtype.g:1574:5: ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) )
+            	    {
+            	    // InternalOXtype.g:1584:5: ( () ( ( ruleOpOther ) ) )
+            	    // InternalOXtype.g:1585:6: () ( ( ruleOpOther ) )
+            	    {
+            	    // InternalOXtype.g:1585:6: ()
+            	    // InternalOXtype.g:1586:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1592:6: ( ( ruleOpOther ) )
+            	    // InternalOXtype.g:1593:7: ( ruleOpOther )
+            	    {
+            	    // InternalOXtype.g:1593:7: ( ruleOpOther )
+            	    // InternalOXtype.g:1594:8: ruleOpOther
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								if (current==null) {
+            	      									current = createModelElement(grammarAccess.getXOtherOperatorExpressionRule());
+            	      								}
+            	      							
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      								newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+            	      							
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpOther();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      								afterParserOrEnumRuleCall();
+            	      							
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1610:4: ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) )
+            	    // InternalOXtype.g:1611:5: (lv_rightOperand_3_0= ruleXAdditiveExpression )
+            	    {
+            	    // InternalOXtype.g:1611:5: (lv_rightOperand_3_0= ruleXAdditiveExpression )
+            	    // InternalOXtype.g:1612:6: lv_rightOperand_3_0= ruleXAdditiveExpression
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXOtherOperatorExpressionAccess().getRightOperandXAdditiveExpressionParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_27);
+            	    lv_rightOperand_3_0=ruleXAdditiveExpression();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXOtherOperatorExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"rightOperand",
+            	      							lv_rightOperand_3_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XAdditiveExpression");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop27;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXOtherOperatorExpression"
+
+
+    // $ANTLR start "entryRuleOpOther"
+    // InternalOXtype.g:1634:1: entryRuleOpOther returns [String current=null] : iv_ruleOpOther= ruleOpOther EOF ;
+    public final String entryRuleOpOther() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpOther = null;
+
+
+        try {
+            // InternalOXtype.g:1634:47: (iv_ruleOpOther= ruleOpOther EOF )
+            // InternalOXtype.g:1635:2: iv_ruleOpOther= ruleOpOther EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpOtherRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpOther=ruleOpOther();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpOther.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpOther"
+
+
+    // $ANTLR start "ruleOpOther"
+    // InternalOXtype.g:1641:1: ruleOpOther returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) ;
+    public final AntlrDatatypeRuleToken ruleOpOther() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1647:2: ( (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' ) )
+            // InternalOXtype.g:1648:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )
+            {
+            // InternalOXtype.g:1648:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )
+            int alt30=9;
+            alt30 = dfa30.predict(input);
+            switch (alt30) {
+                case 1 :
+                    // InternalOXtype.g:1649:3: kw= '->'
+                    {
+                    kw=(Token)match(input,42,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpOtherAccess().getHyphenMinusGreaterThanSignKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:1655:3: kw= '..<'
+                    {
+                    kw=(Token)match(input,43,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopLessThanSignKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:1661:3: (kw= '>' kw= '..' )
+                    {
+                    // InternalOXtype.g:1661:3: (kw= '>' kw= '..' )
+                    // InternalOXtype.g:1662:4: kw= '>' kw= '..'
+                    {
+                    kw=(Token)match(input,33,FOLLOW_28); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_2_0());
+                      			
+                    }
+                    kw=(Token)match(input,44,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_2_1());
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:1674:3: kw= '..'
+                    {
+                    kw=(Token)match(input,44,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpOtherAccess().getFullStopFullStopKeyword_3());
+                      		
+                    }
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:1680:3: kw= '=>'
+                    {
+                    kw=(Token)match(input,45,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_4());
+                      		
+                    }
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:1686:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) )
+                    {
+                    // InternalOXtype.g:1686:3: (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) )
+                    // InternalOXtype.g:1687:4: kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' )
+                    {
+                    kw=(Token)match(input,33,FOLLOW_29); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_0());
+                      			
+                    }
+                    // InternalOXtype.g:1692:4: ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' )
+                    int alt28=2;
+                    int LA28_0 = input.LA(1);
+
+                    if ( (LA28_0==33) ) {
+                        int LA28_1 = input.LA(2);
+
+                        if ( (LA28_1==EOF||(LA28_1>=RULE_STRING && LA28_1<=RULE_ID)||(LA28_1>=13 && LA28_1<=15)||LA28_1==20||(LA28_1>=24 && LA28_1<=25)||LA28_1==32||(LA28_1>=48 && LA28_1<=49)||LA28_1==53||LA28_1==60||LA28_1==63||LA28_1==65||(LA28_1>=69 && LA28_1<=71)||(LA28_1>=74 && LA28_1<=83)||LA28_1==85) ) {
+                            alt28=2;
+                        }
+                        else if ( (LA28_1==33) && (synpred14_InternalOXtype())) {
+                            alt28=1;
+                        }
+                        else {
+                            if (state.backtracking>0) {state.failed=true; return current;}
+                            NoViableAltException nvae =
+                                new NoViableAltException("", 28, 1, input);
+
+                            throw nvae;
+                        }
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return current;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 28, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt28) {
+                        case 1 :
+                            // InternalOXtype.g:1693:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) )
+                            {
+                            // InternalOXtype.g:1693:5: ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) )
+                            // InternalOXtype.g:1694:6: ( ( '>' '>' ) )=> (kw= '>' kw= '>' )
+                            {
+                            // InternalOXtype.g:1699:6: (kw= '>' kw= '>' )
+                            // InternalOXtype.g:1700:7: kw= '>' kw= '>'
+                            {
+                            kw=(Token)match(input,33,FOLLOW_29); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							current.merge(kw);
+                              							newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_0());
+                              						
+                            }
+                            kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							current.merge(kw);
+                              							newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_0_0_1());
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:1713:5: kw= '>'
+                            {
+                            kw=(Token)match(input,33,FOLLOW_2); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(kw);
+                              					newLeafNode(kw, grammarAccess.getOpOtherAccess().getGreaterThanSignKeyword_5_1_1());
+                              				
+                            }
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:1721:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) )
+                    {
+                    // InternalOXtype.g:1721:3: (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) )
+                    // InternalOXtype.g:1722:4: kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' )
+                    {
+                    kw=(Token)match(input,32,FOLLOW_30); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current.merge(kw);
+                      				newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_0());
+                      			
+                    }
+                    // InternalOXtype.g:1727:4: ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' )
+                    int alt29=3;
+                    int LA29_0 = input.LA(1);
+
+                    if ( (LA29_0==32) ) {
+                        int LA29_1 = input.LA(2);
+
+                        if ( (synpred15_InternalOXtype()) ) {
+                            alt29=1;
+                        }
+                        else if ( (true) ) {
+                            alt29=2;
+                        }
+                        else {
+                            if (state.backtracking>0) {state.failed=true; return current;}
+                            NoViableAltException nvae =
+                                new NoViableAltException("", 29, 1, input);
+
+                            throw nvae;
+                        }
+                    }
+                    else if ( (LA29_0==45) ) {
+                        alt29=3;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return current;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 29, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt29) {
+                        case 1 :
+                            // InternalOXtype.g:1728:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) )
+                            {
+                            // InternalOXtype.g:1728:5: ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) )
+                            // InternalOXtype.g:1729:6: ( ( '<' '<' ) )=> (kw= '<' kw= '<' )
+                            {
+                            // InternalOXtype.g:1734:6: (kw= '<' kw= '<' )
+                            // InternalOXtype.g:1735:7: kw= '<' kw= '<'
+                            {
+                            kw=(Token)match(input,32,FOLLOW_19); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							current.merge(kw);
+                              							newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_0());
+                              						
+                            }
+                            kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							current.merge(kw);
+                              							newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_0_0_1());
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:1748:5: kw= '<'
+                            {
+                            kw=(Token)match(input,32,FOLLOW_2); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(kw);
+                              					newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignKeyword_6_1_1());
+                              				
+                            }
+
+                            }
+                            break;
+                        case 3 :
+                            // InternalOXtype.g:1754:5: kw= '=>'
+                            {
+                            kw=(Token)match(input,45,FOLLOW_2); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(kw);
+                              					newLeafNode(kw, grammarAccess.getOpOtherAccess().getEqualsSignGreaterThanSignKeyword_6_1_2());
+                              				
+                            }
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 8 :
+                    // InternalOXtype.g:1762:3: kw= '<>'
+                    {
+                    kw=(Token)match(input,46,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpOtherAccess().getLessThanSignGreaterThanSignKeyword_7());
+                      		
+                    }
+
+                    }
+                    break;
+                case 9 :
+                    // InternalOXtype.g:1768:3: kw= '?:'
+                    {
+                    kw=(Token)match(input,47,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpOtherAccess().getQuestionMarkColonKeyword_8());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpOther"
+
+
+    // $ANTLR start "entryRuleXAdditiveExpression"
+    // InternalOXtype.g:1777:1: entryRuleXAdditiveExpression returns [EObject current=null] : iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF ;
+    public final EObject entryRuleXAdditiveExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXAdditiveExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1777:60: (iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF )
+            // InternalOXtype.g:1778:2: iv_ruleXAdditiveExpression= ruleXAdditiveExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXAdditiveExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXAdditiveExpression=ruleXAdditiveExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXAdditiveExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXAdditiveExpression"
+
+
+    // $ANTLR start "ruleXAdditiveExpression"
+    // InternalOXtype.g:1784:1: ruleXAdditiveExpression returns [EObject current=null] : (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) ;
+    public final EObject ruleXAdditiveExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XMultiplicativeExpression_0 = null;
+
+        EObject lv_rightOperand_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1790:2: ( (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* ) )
+            // InternalOXtype.g:1791:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* )
+            {
+            // InternalOXtype.g:1791:2: (this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )* )
+            // InternalOXtype.g:1792:3: this_XMultiplicativeExpression_0= ruleXMultiplicativeExpression ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getXMultiplicativeExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_31);
+            this_XMultiplicativeExpression_0=ruleXMultiplicativeExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XMultiplicativeExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1800:3: ( ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) ) )*
+            loop31:
+            do {
+                int alt31=2;
+                int LA31_0 = input.LA(1);
+
+                if ( (LA31_0==48) ) {
+                    int LA31_2 = input.LA(2);
+
+                    if ( (synpred16_InternalOXtype()) ) {
+                        alt31=1;
+                    }
+
+
+                }
+                else if ( (LA31_0==49) ) {
+                    int LA31_3 = input.LA(2);
+
+                    if ( (synpred16_InternalOXtype()) ) {
+                        alt31=1;
+                    }
+
+
+                }
+
+
+                switch (alt31) {
+            	case 1 :
+            	    // InternalOXtype.g:1801:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) ) ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) )
+            	    {
+            	    // InternalOXtype.g:1801:4: ( ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) ) )
+            	    // InternalOXtype.g:1802:5: ( ( () ( ( ruleOpAdd ) ) ) )=> ( () ( ( ruleOpAdd ) ) )
+            	    {
+            	    // InternalOXtype.g:1812:5: ( () ( ( ruleOpAdd ) ) )
+            	    // InternalOXtype.g:1813:6: () ( ( ruleOpAdd ) )
+            	    {
+            	    // InternalOXtype.g:1813:6: ()
+            	    // InternalOXtype.g:1814:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1820:6: ( ( ruleOpAdd ) )
+            	    // InternalOXtype.g:1821:7: ( ruleOpAdd )
+            	    {
+            	    // InternalOXtype.g:1821:7: ( ruleOpAdd )
+            	    // InternalOXtype.g:1822:8: ruleOpAdd
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								if (current==null) {
+            	      									current = createModelElement(grammarAccess.getXAdditiveExpressionRule());
+            	      								}
+            	      							
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      								newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+            	      							
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpAdd();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      								afterParserOrEnumRuleCall();
+            	      							
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1838:4: ( (lv_rightOperand_3_0= ruleXMultiplicativeExpression ) )
+            	    // InternalOXtype.g:1839:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression )
+            	    {
+            	    // InternalOXtype.g:1839:5: (lv_rightOperand_3_0= ruleXMultiplicativeExpression )
+            	    // InternalOXtype.g:1840:6: lv_rightOperand_3_0= ruleXMultiplicativeExpression
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXAdditiveExpressionAccess().getRightOperandXMultiplicativeExpressionParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_31);
+            	    lv_rightOperand_3_0=ruleXMultiplicativeExpression();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXAdditiveExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"rightOperand",
+            	      							lv_rightOperand_3_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XMultiplicativeExpression");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop31;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXAdditiveExpression"
+
+
+    // $ANTLR start "entryRuleOpAdd"
+    // InternalOXtype.g:1862:1: entryRuleOpAdd returns [String current=null] : iv_ruleOpAdd= ruleOpAdd EOF ;
+    public final String entryRuleOpAdd() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpAdd = null;
+
+
+        try {
+            // InternalOXtype.g:1862:45: (iv_ruleOpAdd= ruleOpAdd EOF )
+            // InternalOXtype.g:1863:2: iv_ruleOpAdd= ruleOpAdd EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpAddRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpAdd=ruleOpAdd();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpAdd.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpAdd"
+
+
+    // $ANTLR start "ruleOpAdd"
+    // InternalOXtype.g:1869:1: ruleOpAdd returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '+' | kw= '-' ) ;
+    public final AntlrDatatypeRuleToken ruleOpAdd() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1875:2: ( (kw= '+' | kw= '-' ) )
+            // InternalOXtype.g:1876:2: (kw= '+' | kw= '-' )
+            {
+            // InternalOXtype.g:1876:2: (kw= '+' | kw= '-' )
+            int alt32=2;
+            int LA32_0 = input.LA(1);
+
+            if ( (LA32_0==48) ) {
+                alt32=1;
+            }
+            else if ( (LA32_0==49) ) {
+                alt32=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 32, 0, input);
+
+                throw nvae;
+            }
+            switch (alt32) {
+                case 1 :
+                    // InternalOXtype.g:1877:3: kw= '+'
+                    {
+                    kw=(Token)match(input,48,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpAddAccess().getPlusSignKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:1883:3: kw= '-'
+                    {
+                    kw=(Token)match(input,49,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpAddAccess().getHyphenMinusKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpAdd"
+
+
+    // $ANTLR start "entryRuleXMultiplicativeExpression"
+    // InternalOXtype.g:1892:1: entryRuleXMultiplicativeExpression returns [EObject current=null] : iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF ;
+    public final EObject entryRuleXMultiplicativeExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXMultiplicativeExpression = null;
+
+
+        try {
+            // InternalOXtype.g:1892:66: (iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF )
+            // InternalOXtype.g:1893:2: iv_ruleXMultiplicativeExpression= ruleXMultiplicativeExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXMultiplicativeExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXMultiplicativeExpression=ruleXMultiplicativeExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXMultiplicativeExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXMultiplicativeExpression"
+
+
+    // $ANTLR start "ruleXMultiplicativeExpression"
+    // InternalOXtype.g:1899:1: ruleXMultiplicativeExpression returns [EObject current=null] : (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) ;
+    public final EObject ruleXMultiplicativeExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XUnaryOperation_0 = null;
+
+        EObject lv_rightOperand_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1905:2: ( (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* ) )
+            // InternalOXtype.g:1906:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* )
+            {
+            // InternalOXtype.g:1906:2: (this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )* )
+            // InternalOXtype.g:1907:3: this_XUnaryOperation_0= ruleXUnaryOperation ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getXUnaryOperationParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_32);
+            this_XUnaryOperation_0=ruleXUnaryOperation();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XUnaryOperation_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:1915:3: ( ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) ) )*
+            loop33:
+            do {
+                int alt33=2;
+                switch ( input.LA(1) ) {
+                case 16:
+                    {
+                    int LA33_2 = input.LA(2);
+
+                    if ( (synpred17_InternalOXtype()) ) {
+                        alt33=1;
+                    }
+
+
+                    }
+                    break;
+                case 50:
+                    {
+                    int LA33_3 = input.LA(2);
+
+                    if ( (synpred17_InternalOXtype()) ) {
+                        alt33=1;
+                    }
+
+
+                    }
+                    break;
+                case 51:
+                    {
+                    int LA33_4 = input.LA(2);
+
+                    if ( (synpred17_InternalOXtype()) ) {
+                        alt33=1;
+                    }
+
+
+                    }
+                    break;
+                case 52:
+                    {
+                    int LA33_5 = input.LA(2);
+
+                    if ( (synpred17_InternalOXtype()) ) {
+                        alt33=1;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt33) {
+            	case 1 :
+            	    // InternalOXtype.g:1916:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) ) ( (lv_rightOperand_3_0= ruleXUnaryOperation ) )
+            	    {
+            	    // InternalOXtype.g:1916:4: ( ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) ) )
+            	    // InternalOXtype.g:1917:5: ( ( () ( ( ruleOpMulti ) ) ) )=> ( () ( ( ruleOpMulti ) ) )
+            	    {
+            	    // InternalOXtype.g:1927:5: ( () ( ( ruleOpMulti ) ) )
+            	    // InternalOXtype.g:1928:6: () ( ( ruleOpMulti ) )
+            	    {
+            	    // InternalOXtype.g:1928:6: ()
+            	    // InternalOXtype.g:1929:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:1935:6: ( ( ruleOpMulti ) )
+            	    // InternalOXtype.g:1936:7: ( ruleOpMulti )
+            	    {
+            	    // InternalOXtype.g:1936:7: ( ruleOpMulti )
+            	    // InternalOXtype.g:1937:8: ruleOpMulti
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								if (current==null) {
+            	      									current = createModelElement(grammarAccess.getXMultiplicativeExpressionRule());
+            	      								}
+            	      							
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      								newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_1_0());
+            	      							
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpMulti();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      								afterParserOrEnumRuleCall();
+            	      							
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:1953:4: ( (lv_rightOperand_3_0= ruleXUnaryOperation ) )
+            	    // InternalOXtype.g:1954:5: (lv_rightOperand_3_0= ruleXUnaryOperation )
+            	    {
+            	    // InternalOXtype.g:1954:5: (lv_rightOperand_3_0= ruleXUnaryOperation )
+            	    // InternalOXtype.g:1955:6: lv_rightOperand_3_0= ruleXUnaryOperation
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXMultiplicativeExpressionAccess().getRightOperandXUnaryOperationParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_32);
+            	    lv_rightOperand_3_0=ruleXUnaryOperation();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXMultiplicativeExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"rightOperand",
+            	      							lv_rightOperand_3_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop33;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXMultiplicativeExpression"
+
+
+    // $ANTLR start "entryRuleOpMulti"
+    // InternalOXtype.g:1977:1: entryRuleOpMulti returns [String current=null] : iv_ruleOpMulti= ruleOpMulti EOF ;
+    public final String entryRuleOpMulti() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpMulti = null;
+
+
+        try {
+            // InternalOXtype.g:1977:47: (iv_ruleOpMulti= ruleOpMulti EOF )
+            // InternalOXtype.g:1978:2: iv_ruleOpMulti= ruleOpMulti EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpMultiRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpMulti=ruleOpMulti();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpMulti.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpMulti"
+
+
+    // $ANTLR start "ruleOpMulti"
+    // InternalOXtype.g:1984:1: ruleOpMulti returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) ;
+    public final AntlrDatatypeRuleToken ruleOpMulti() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:1990:2: ( (kw= '*' | kw= '**' | kw= '/' | kw= '%' ) )
+            // InternalOXtype.g:1991:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' )
+            {
+            // InternalOXtype.g:1991:2: (kw= '*' | kw= '**' | kw= '/' | kw= '%' )
+            int alt34=4;
+            switch ( input.LA(1) ) {
+            case 16:
+                {
+                alt34=1;
+                }
+                break;
+            case 50:
+                {
+                alt34=2;
+                }
+                break;
+            case 51:
+                {
+                alt34=3;
+                }
+                break;
+            case 52:
+                {
+                alt34=4;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 34, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt34) {
+                case 1 :
+                    // InternalOXtype.g:1992:3: kw= '*'
+                    {
+                    kw=(Token)match(input,16,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:1998:3: kw= '**'
+                    {
+                    kw=(Token)match(input,50,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAccess().getAsteriskAsteriskKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2004:3: kw= '/'
+                    {
+                    kw=(Token)match(input,51,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAccess().getSolidusKeyword_2());
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2010:3: kw= '%'
+                    {
+                    kw=(Token)match(input,52,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpMultiAccess().getPercentSignKeyword_3());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpMulti"
+
+
+    // $ANTLR start "entryRuleXUnaryOperation"
+    // InternalOXtype.g:2019:1: entryRuleXUnaryOperation returns [EObject current=null] : iv_ruleXUnaryOperation= ruleXUnaryOperation EOF ;
+    public final EObject entryRuleXUnaryOperation() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXUnaryOperation = null;
+
+
+        try {
+            // InternalOXtype.g:2019:56: (iv_ruleXUnaryOperation= ruleXUnaryOperation EOF )
+            // InternalOXtype.g:2020:2: iv_ruleXUnaryOperation= ruleXUnaryOperation EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXUnaryOperationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXUnaryOperation=ruleXUnaryOperation();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXUnaryOperation; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXUnaryOperation"
+
+
+    // $ANTLR start "ruleXUnaryOperation"
+    // InternalOXtype.g:2026:1: ruleXUnaryOperation returns [EObject current=null] : ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) ;
+    public final EObject ruleXUnaryOperation() throws RecognitionException {
+        EObject current = null;
+
+        EObject lv_operand_2_0 = null;
+
+        EObject this_XCastedExpression_3 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2032:2: ( ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression ) )
+            // InternalOXtype.g:2033:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression )
+            {
+            // InternalOXtype.g:2033:2: ( ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) ) | this_XCastedExpression_3= ruleXCastedExpression )
+            int alt35=2;
+            int LA35_0 = input.LA(1);
+
+            if ( ((LA35_0>=48 && LA35_0<=49)||LA35_0==53) ) {
+                alt35=1;
+            }
+            else if ( ((LA35_0>=RULE_STRING && LA35_0<=RULE_ID)||(LA35_0>=13 && LA35_0<=15)||LA35_0==20||(LA35_0>=24 && LA35_0<=25)||LA35_0==32||LA35_0==60||LA35_0==63||LA35_0==65||(LA35_0>=69 && LA35_0<=71)||(LA35_0>=74 && LA35_0<=83)||LA35_0==85) ) {
+                alt35=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 35, 0, input);
+
+                throw nvae;
+            }
+            switch (alt35) {
+                case 1 :
+                    // InternalOXtype.g:2034:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) )
+                    {
+                    // InternalOXtype.g:2034:3: ( () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) ) )
+                    // InternalOXtype.g:2035:4: () ( ( ruleOpUnary ) ) ( (lv_operand_2_0= ruleXUnaryOperation ) )
+                    {
+                    // InternalOXtype.g:2035:4: ()
+                    // InternalOXtype.g:2036:5: 
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					current = forceCreateModelElement(
+                      						grammarAccess.getXUnaryOperationAccess().getXUnaryOperationAction_0_0(),
+                      						current);
+                      				
+                    }
+
+                    }
+
+                    // InternalOXtype.g:2042:4: ( ( ruleOpUnary ) )
+                    // InternalOXtype.g:2043:5: ( ruleOpUnary )
+                    {
+                    // InternalOXtype.g:2043:5: ( ruleOpUnary )
+                    // InternalOXtype.g:2044:6: ruleOpUnary
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXUnaryOperationRule());
+                      						}
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXUnaryOperationAccess().getFeatureJvmIdentifiableElementCrossReference_0_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_13);
+                    ruleOpUnary();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:2058:4: ( (lv_operand_2_0= ruleXUnaryOperation ) )
+                    // InternalOXtype.g:2059:5: (lv_operand_2_0= ruleXUnaryOperation )
+                    {
+                    // InternalOXtype.g:2059:5: (lv_operand_2_0= ruleXUnaryOperation )
+                    // InternalOXtype.g:2060:6: lv_operand_2_0= ruleXUnaryOperation
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXUnaryOperationAccess().getOperandXUnaryOperationParserRuleCall_0_2_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_operand_2_0=ruleXUnaryOperation();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXUnaryOperationRule());
+                      						}
+                      						set(
+                      							current,
+                      							"operand",
+                      							lv_operand_2_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XUnaryOperation");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2079:3: this_XCastedExpression_3= ruleXCastedExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXUnaryOperationAccess().getXCastedExpressionParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XCastedExpression_3=ruleXCastedExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XCastedExpression_3;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXUnaryOperation"
+
+
+    // $ANTLR start "entryRuleOpUnary"
+    // InternalOXtype.g:2091:1: entryRuleOpUnary returns [String current=null] : iv_ruleOpUnary= ruleOpUnary EOF ;
+    public final String entryRuleOpUnary() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpUnary = null;
+
+
+        try {
+            // InternalOXtype.g:2091:47: (iv_ruleOpUnary= ruleOpUnary EOF )
+            // InternalOXtype.g:2092:2: iv_ruleOpUnary= ruleOpUnary EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpUnaryRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpUnary=ruleOpUnary();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpUnary.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpUnary"
+
+
+    // $ANTLR start "ruleOpUnary"
+    // InternalOXtype.g:2098:1: ruleOpUnary returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '!' | kw= '-' | kw= '+' ) ;
+    public final AntlrDatatypeRuleToken ruleOpUnary() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2104:2: ( (kw= '!' | kw= '-' | kw= '+' ) )
+            // InternalOXtype.g:2105:2: (kw= '!' | kw= '-' | kw= '+' )
+            {
+            // InternalOXtype.g:2105:2: (kw= '!' | kw= '-' | kw= '+' )
+            int alt36=3;
+            switch ( input.LA(1) ) {
+            case 53:
+                {
+                alt36=1;
+                }
+                break;
+            case 49:
+                {
+                alt36=2;
+                }
+                break;
+            case 48:
+                {
+                alt36=3;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 36, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt36) {
+                case 1 :
+                    // InternalOXtype.g:2106:3: kw= '!'
+                    {
+                    kw=(Token)match(input,53,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpUnaryAccess().getExclamationMarkKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2112:3: kw= '-'
+                    {
+                    kw=(Token)match(input,49,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpUnaryAccess().getHyphenMinusKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2118:3: kw= '+'
+                    {
+                    kw=(Token)match(input,48,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpUnaryAccess().getPlusSignKeyword_2());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpUnary"
+
+
+    // $ANTLR start "entryRuleXCastedExpression"
+    // InternalOXtype.g:2127:1: entryRuleXCastedExpression returns [EObject current=null] : iv_ruleXCastedExpression= ruleXCastedExpression EOF ;
+    public final EObject entryRuleXCastedExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXCastedExpression = null;
+
+
+        try {
+            // InternalOXtype.g:2127:58: (iv_ruleXCastedExpression= ruleXCastedExpression EOF )
+            // InternalOXtype.g:2128:2: iv_ruleXCastedExpression= ruleXCastedExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXCastedExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXCastedExpression=ruleXCastedExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXCastedExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXCastedExpression"
+
+
+    // $ANTLR start "ruleXCastedExpression"
+    // InternalOXtype.g:2134:1: ruleXCastedExpression returns [EObject current=null] : (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) ;
+    public final EObject ruleXCastedExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_2=null;
+        EObject this_XPostfixOperation_0 = null;
+
+        EObject lv_type_3_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2140:2: ( (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* ) )
+            // InternalOXtype.g:2141:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* )
+            {
+            // InternalOXtype.g:2141:2: (this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )* )
+            // InternalOXtype.g:2142:3: this_XPostfixOperation_0= ruleXPostfixOperation ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXCastedExpressionAccess().getXPostfixOperationParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_33);
+            this_XPostfixOperation_0=ruleXPostfixOperation();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XPostfixOperation_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:2150:3: ( ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) ) )*
+            loop37:
+            do {
+                int alt37=2;
+                int LA37_0 = input.LA(1);
+
+                if ( (LA37_0==54) ) {
+                    int LA37_2 = input.LA(2);
+
+                    if ( (synpred18_InternalOXtype()) ) {
+                        alt37=1;
+                    }
+
+
+                }
+
+
+                switch (alt37) {
+            	case 1 :
+            	    // InternalOXtype.g:2151:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) ) ( (lv_type_3_0= ruleJvmTypeReference ) )
+            	    {
+            	    // InternalOXtype.g:2151:4: ( ( ( () 'as' ) )=> ( () otherlv_2= 'as' ) )
+            	    // InternalOXtype.g:2152:5: ( ( () 'as' ) )=> ( () otherlv_2= 'as' )
+            	    {
+            	    // InternalOXtype.g:2158:5: ( () otherlv_2= 'as' )
+            	    // InternalOXtype.g:2159:6: () otherlv_2= 'as'
+            	    {
+            	    // InternalOXtype.g:2159:6: ()
+            	    // InternalOXtype.g:2160:7: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							current = forceCreateModelElementAndSet(
+            	      								grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0(),
+            	      								current);
+            	      						
+            	    }
+
+            	    }
+
+            	    otherlv_2=(Token)match(input,54,FOLLOW_26); if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						newLeafNode(otherlv_2, grammarAccess.getXCastedExpressionAccess().getAsKeyword_1_0_0_1());
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:2172:4: ( (lv_type_3_0= ruleJvmTypeReference ) )
+            	    // InternalOXtype.g:2173:5: (lv_type_3_0= ruleJvmTypeReference )
+            	    {
+            	    // InternalOXtype.g:2173:5: (lv_type_3_0= ruleJvmTypeReference )
+            	    // InternalOXtype.g:2174:6: lv_type_3_0= ruleJvmTypeReference
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXCastedExpressionAccess().getTypeJvmTypeReferenceParserRuleCall_1_1_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_33);
+            	    lv_type_3_0=ruleJvmTypeReference();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXCastedExpressionRule());
+            	      						}
+            	      						set(
+            	      							current,
+            	      							"type",
+            	      							lv_type_3_0,
+            	      							"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop37;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXCastedExpression"
+
+
+    // $ANTLR start "entryRuleXPostfixOperation"
+    // InternalOXtype.g:2196:1: entryRuleXPostfixOperation returns [EObject current=null] : iv_ruleXPostfixOperation= ruleXPostfixOperation EOF ;
+    public final EObject entryRuleXPostfixOperation() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXPostfixOperation = null;
+
+
+        try {
+            // InternalOXtype.g:2196:58: (iv_ruleXPostfixOperation= ruleXPostfixOperation EOF )
+            // InternalOXtype.g:2197:2: iv_ruleXPostfixOperation= ruleXPostfixOperation EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXPostfixOperationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXPostfixOperation=ruleXPostfixOperation();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXPostfixOperation; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXPostfixOperation"
+
+
+    // $ANTLR start "ruleXPostfixOperation"
+    // InternalOXtype.g:2203:1: ruleXPostfixOperation returns [EObject current=null] : (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) ;
+    public final EObject ruleXPostfixOperation() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XMemberFeatureCall_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2209:2: ( (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? ) )
+            // InternalOXtype.g:2210:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? )
+            {
+            // InternalOXtype.g:2210:2: (this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )? )
+            // InternalOXtype.g:2211:3: this_XMemberFeatureCall_0= ruleXMemberFeatureCall ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )?
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXPostfixOperationAccess().getXMemberFeatureCallParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_34);
+            this_XMemberFeatureCall_0=ruleXMemberFeatureCall();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XMemberFeatureCall_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:2219:3: ( ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) ) )?
+            int alt38=2;
+            int LA38_0 = input.LA(1);
+
+            if ( (LA38_0==55) ) {
+                int LA38_1 = input.LA(2);
+
+                if ( (synpred19_InternalOXtype()) ) {
+                    alt38=1;
+                }
+            }
+            else if ( (LA38_0==56) ) {
+                int LA38_2 = input.LA(2);
+
+                if ( (synpred19_InternalOXtype()) ) {
+                    alt38=1;
+                }
+            }
+            switch (alt38) {
+                case 1 :
+                    // InternalOXtype.g:2220:4: ( ( () ( ( ruleOpPostfix ) ) ) )=> ( () ( ( ruleOpPostfix ) ) )
+                    {
+                    // InternalOXtype.g:2230:4: ( () ( ( ruleOpPostfix ) ) )
+                    // InternalOXtype.g:2231:5: () ( ( ruleOpPostfix ) )
+                    {
+                    // InternalOXtype.g:2231:5: ()
+                    // InternalOXtype.g:2232:6: 
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						current = forceCreateModelElementAndSet(
+                      							grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0(),
+                      							current);
+                      					
+                    }
+
+                    }
+
+                    // InternalOXtype.g:2238:5: ( ( ruleOpPostfix ) )
+                    // InternalOXtype.g:2239:6: ( ruleOpPostfix )
+                    {
+                    // InternalOXtype.g:2239:6: ( ruleOpPostfix )
+                    // InternalOXtype.g:2240:7: ruleOpPostfix
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElement(grammarAccess.getXPostfixOperationRule());
+                      							}
+                      						
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXPostfixOperationAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_1_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_2);
+                    ruleOpPostfix();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXPostfixOperation"
+
+
+    // $ANTLR start "entryRuleOpPostfix"
+    // InternalOXtype.g:2260:1: entryRuleOpPostfix returns [String current=null] : iv_ruleOpPostfix= ruleOpPostfix EOF ;
+    public final String entryRuleOpPostfix() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleOpPostfix = null;
+
+
+        try {
+            // InternalOXtype.g:2260:49: (iv_ruleOpPostfix= ruleOpPostfix EOF )
+            // InternalOXtype.g:2261:2: iv_ruleOpPostfix= ruleOpPostfix EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getOpPostfixRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleOpPostfix=ruleOpPostfix();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleOpPostfix.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleOpPostfix"
+
+
+    // $ANTLR start "ruleOpPostfix"
+    // InternalOXtype.g:2267:1: ruleOpPostfix returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '++' | kw= '--' ) ;
+    public final AntlrDatatypeRuleToken ruleOpPostfix() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2273:2: ( (kw= '++' | kw= '--' ) )
+            // InternalOXtype.g:2274:2: (kw= '++' | kw= '--' )
+            {
+            // InternalOXtype.g:2274:2: (kw= '++' | kw= '--' )
+            int alt39=2;
+            int LA39_0 = input.LA(1);
+
+            if ( (LA39_0==55) ) {
+                alt39=1;
+            }
+            else if ( (LA39_0==56) ) {
+                alt39=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 39, 0, input);
+
+                throw nvae;
+            }
+            switch (alt39) {
+                case 1 :
+                    // InternalOXtype.g:2275:3: kw= '++'
+                    {
+                    kw=(Token)match(input,55,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpPostfixAccess().getPlusSignPlusSignKeyword_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2281:3: kw= '--'
+                    {
+                    kw=(Token)match(input,56,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getOpPostfixAccess().getHyphenMinusHyphenMinusKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleOpPostfix"
+
+
+    // $ANTLR start "entryRuleXMemberFeatureCall"
+    // InternalOXtype.g:2290:1: entryRuleXMemberFeatureCall returns [EObject current=null] : iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF ;
+    public final EObject entryRuleXMemberFeatureCall() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXMemberFeatureCall = null;
+
+
+        try {
+            // InternalOXtype.g:2290:59: (iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF )
+            // InternalOXtype.g:2291:2: iv_ruleXMemberFeatureCall= ruleXMemberFeatureCall EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXMemberFeatureCallRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXMemberFeatureCall=ruleXMemberFeatureCall();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXMemberFeatureCall; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXMemberFeatureCall"
+
+
+    // $ANTLR start "ruleXMemberFeatureCall"
+    // InternalOXtype.g:2297:1: ruleXMemberFeatureCall returns [EObject current=null] : (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) ;
+    public final EObject ruleXMemberFeatureCall() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_2=null;
+        Token lv_explicitStatic_3_0=null;
+        Token otherlv_8=null;
+        Token lv_nullSafe_9_0=null;
+        Token lv_explicitStatic_10_0=null;
+        Token otherlv_11=null;
+        Token otherlv_13=null;
+        Token otherlv_15=null;
+        Token lv_explicitOperationCall_17_0=null;
+        Token otherlv_20=null;
+        Token otherlv_22=null;
+        EObject this_XPrimaryExpression_0 = null;
+
+        EObject lv_value_6_0 = null;
+
+        EObject lv_typeArguments_12_0 = null;
+
+        EObject lv_typeArguments_14_0 = null;
+
+        EObject lv_memberCallArguments_18_0 = null;
+
+        EObject lv_memberCallArguments_19_0 = null;
+
+        EObject lv_memberCallArguments_21_0 = null;
+
+        EObject lv_memberCallArguments_23_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2303:2: ( (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* ) )
+            // InternalOXtype.g:2304:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* )
+            {
+            // InternalOXtype.g:2304:2: (this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )* )
+            // InternalOXtype.g:2305:3: this_XPrimaryExpression_0= ruleXPrimaryExpression ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getXPrimaryExpressionParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_35);
+            this_XPrimaryExpression_0=ruleXPrimaryExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XPrimaryExpression_0;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:2313:3: ( ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) ) | ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? ) )*
+            loop48:
+            do {
+                int alt48=3;
+                switch ( input.LA(1) ) {
+                case 57:
+                    {
+                    int LA48_2 = input.LA(2);
+
+                    if ( (synpred20_InternalOXtype()) ) {
+                        alt48=1;
+                    }
+                    else if ( (synpred21_InternalOXtype()) ) {
+                        alt48=2;
+                    }
+
+
+                    }
+                    break;
+                case 58:
+                    {
+                    int LA48_3 = input.LA(2);
+
+                    if ( (synpred20_InternalOXtype()) ) {
+                        alt48=1;
+                    }
+                    else if ( (synpred21_InternalOXtype()) ) {
+                        alt48=2;
+                    }
+
+
+                    }
+                    break;
+                case 59:
+                    {
+                    int LA48_4 = input.LA(2);
+
+                    if ( (synpred21_InternalOXtype()) ) {
+                        alt48=2;
+                    }
+
+
+                    }
+                    break;
+
+                }
+
+                switch (alt48) {
+            	case 1 :
+            	    // InternalOXtype.g:2314:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) )
+            	    {
+            	    // InternalOXtype.g:2314:4: ( ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) ) )
+            	    // InternalOXtype.g:2315:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) ) ( (lv_value_6_0= ruleXAssignment ) )
+            	    {
+            	    // InternalOXtype.g:2315:5: ( ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )
+            	    // InternalOXtype.g:2316:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )=> ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+            	    {
+            	    // InternalOXtype.g:2336:6: ( () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+            	    // InternalOXtype.g:2337:7: () (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign
+            	    {
+            	    // InternalOXtype.g:2337:7: ()
+            	    // InternalOXtype.g:2338:8: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								current = forceCreateModelElementAndSet(
+            	      									grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0(),
+            	      									current);
+            	      							
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:2344:7: (otherlv_2= '.' | ( (lv_explicitStatic_3_0= '::' ) ) )
+            	    int alt40=2;
+            	    int LA40_0 = input.LA(1);
+
+            	    if ( (LA40_0==57) ) {
+            	        alt40=1;
+            	    }
+            	    else if ( (LA40_0==58) ) {
+            	        alt40=2;
+            	    }
+            	    else {
+            	        if (state.backtracking>0) {state.failed=true; return current;}
+            	        NoViableAltException nvae =
+            	            new NoViableAltException("", 40, 0, input);
+
+            	        throw nvae;
+            	    }
+            	    switch (alt40) {
+            	        case 1 :
+            	            // InternalOXtype.g:2345:8: otherlv_2= '.'
+            	            {
+            	            otherlv_2=(Token)match(input,57,FOLLOW_36); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              								newLeafNode(otherlv_2, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_0_0_0_1_0());
+            	              							
+            	            }
+
+            	            }
+            	            break;
+            	        case 2 :
+            	            // InternalOXtype.g:2350:8: ( (lv_explicitStatic_3_0= '::' ) )
+            	            {
+            	            // InternalOXtype.g:2350:8: ( (lv_explicitStatic_3_0= '::' ) )
+            	            // InternalOXtype.g:2351:9: (lv_explicitStatic_3_0= '::' )
+            	            {
+            	            // InternalOXtype.g:2351:9: (lv_explicitStatic_3_0= '::' )
+            	            // InternalOXtype.g:2352:10: lv_explicitStatic_3_0= '::'
+            	            {
+            	            lv_explicitStatic_3_0=(Token)match(input,58,FOLLOW_36); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              										newLeafNode(lv_explicitStatic_3_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_0_0_0_1_1_0());
+            	              									
+            	            }
+            	            if ( state.backtracking==0 ) {
+
+            	              										if (current==null) {
+            	              											current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+            	              										}
+            	              										setWithLastConsumed(current, "explicitStatic", true, "::");
+            	              									
+            	            }
+
+            	            }
+
+
+            	            }
+
+
+            	            }
+            	            break;
+
+            	    }
+
+            	    // InternalOXtype.g:2365:7: ( ( ruleFeatureCallID ) )
+            	    // InternalOXtype.g:2366:8: ( ruleFeatureCallID )
+            	    {
+            	    // InternalOXtype.g:2366:8: ( ruleFeatureCallID )
+            	    // InternalOXtype.g:2367:9: ruleFeatureCallID
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      									if (current==null) {
+            	      										current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+            	      									}
+            	      								
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      									newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_0_0_0_2_0());
+            	      								
+            	    }
+            	    pushFollow(FOLLOW_12);
+            	    ruleFeatureCallID();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      									afterParserOrEnumRuleCall();
+            	      								
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    if ( state.backtracking==0 ) {
+
+            	      							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getOpSingleAssignParserRuleCall_1_0_0_0_3());
+            	      						
+            	    }
+            	    pushFollow(FOLLOW_13);
+            	    ruleOpSingleAssign();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      							afterParserOrEnumRuleCall();
+            	      						
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:2390:5: ( (lv_value_6_0= ruleXAssignment ) )
+            	    // InternalOXtype.g:2391:6: (lv_value_6_0= ruleXAssignment )
+            	    {
+            	    // InternalOXtype.g:2391:6: (lv_value_6_0= ruleXAssignment )
+            	    // InternalOXtype.g:2392:7: lv_value_6_0= ruleXAssignment
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getValueXAssignmentParserRuleCall_1_0_1_0());
+            	      						
+            	    }
+            	    pushFollow(FOLLOW_35);
+            	    lv_value_6_0=ruleXAssignment();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      							if (current==null) {
+            	      								current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	      							}
+            	      							set(
+            	      								current,
+            	      								"value",
+            	      								lv_value_6_0,
+            	      								"org.eclipse.xtext.xbase.Xbase.XAssignment");
+            	      							afterParserOrEnumRuleCall();
+            	      						
+            	    }
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+            	case 2 :
+            	    // InternalOXtype.g:2411:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? )
+            	    {
+            	    // InternalOXtype.g:2411:4: ( ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )? )
+            	    // InternalOXtype.g:2412:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) ) (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )? ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?
+            	    {
+            	    // InternalOXtype.g:2412:5: ( ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) ) )
+            	    // InternalOXtype.g:2413:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )=> ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) )
+            	    {
+            	    // InternalOXtype.g:2433:6: ( () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) ) )
+            	    // InternalOXtype.g:2434:7: () (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) )
+            	    {
+            	    // InternalOXtype.g:2434:7: ()
+            	    // InternalOXtype.g:2435:8: 
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      								current = forceCreateModelElementAndSet(
+            	      									grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0(),
+            	      									current);
+            	      							
+            	    }
+
+            	    }
+
+            	    // InternalOXtype.g:2441:7: (otherlv_8= '.' | ( (lv_nullSafe_9_0= '?.' ) ) | ( (lv_explicitStatic_10_0= '::' ) ) )
+            	    int alt41=3;
+            	    switch ( input.LA(1) ) {
+            	    case 57:
+            	        {
+            	        alt41=1;
+            	        }
+            	        break;
+            	    case 59:
+            	        {
+            	        alt41=2;
+            	        }
+            	        break;
+            	    case 58:
+            	        {
+            	        alt41=3;
+            	        }
+            	        break;
+            	    default:
+            	        if (state.backtracking>0) {state.failed=true; return current;}
+            	        NoViableAltException nvae =
+            	            new NoViableAltException("", 41, 0, input);
+
+            	        throw nvae;
+            	    }
+
+            	    switch (alt41) {
+            	        case 1 :
+            	            // InternalOXtype.g:2442:8: otherlv_8= '.'
+            	            {
+            	            otherlv_8=(Token)match(input,57,FOLLOW_37); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              								newLeafNode(otherlv_8, grammarAccess.getXMemberFeatureCallAccess().getFullStopKeyword_1_1_0_0_1_0());
+            	              							
+            	            }
+
+            	            }
+            	            break;
+            	        case 2 :
+            	            // InternalOXtype.g:2447:8: ( (lv_nullSafe_9_0= '?.' ) )
+            	            {
+            	            // InternalOXtype.g:2447:8: ( (lv_nullSafe_9_0= '?.' ) )
+            	            // InternalOXtype.g:2448:9: (lv_nullSafe_9_0= '?.' )
+            	            {
+            	            // InternalOXtype.g:2448:9: (lv_nullSafe_9_0= '?.' )
+            	            // InternalOXtype.g:2449:10: lv_nullSafe_9_0= '?.'
+            	            {
+            	            lv_nullSafe_9_0=(Token)match(input,59,FOLLOW_37); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              										newLeafNode(lv_nullSafe_9_0, grammarAccess.getXMemberFeatureCallAccess().getNullSafeQuestionMarkFullStopKeyword_1_1_0_0_1_1_0());
+            	              									
+            	            }
+            	            if ( state.backtracking==0 ) {
+
+            	              										if (current==null) {
+            	              											current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+            	              										}
+            	              										setWithLastConsumed(current, "nullSafe", true, "?.");
+            	              									
+            	            }
+
+            	            }
+
+
+            	            }
+
+
+            	            }
+            	            break;
+            	        case 3 :
+            	            // InternalOXtype.g:2462:8: ( (lv_explicitStatic_10_0= '::' ) )
+            	            {
+            	            // InternalOXtype.g:2462:8: ( (lv_explicitStatic_10_0= '::' ) )
+            	            // InternalOXtype.g:2463:9: (lv_explicitStatic_10_0= '::' )
+            	            {
+            	            // InternalOXtype.g:2463:9: (lv_explicitStatic_10_0= '::' )
+            	            // InternalOXtype.g:2464:10: lv_explicitStatic_10_0= '::'
+            	            {
+            	            lv_explicitStatic_10_0=(Token)match(input,58,FOLLOW_37); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              										newLeafNode(lv_explicitStatic_10_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitStaticColonColonKeyword_1_1_0_0_1_2_0());
+            	              									
+            	            }
+            	            if ( state.backtracking==0 ) {
+
+            	              										if (current==null) {
+            	              											current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+            	              										}
+            	              										setWithLastConsumed(current, "explicitStatic", true, "::");
+            	              									
+            	            }
+
+            	            }
+
+
+            	            }
+
+
+            	            }
+            	            break;
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:2479:5: (otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>' )?
+            	    int alt43=2;
+            	    int LA43_0 = input.LA(1);
+
+            	    if ( (LA43_0==32) ) {
+            	        alt43=1;
+            	    }
+            	    switch (alt43) {
+            	        case 1 :
+            	            // InternalOXtype.g:2480:6: otherlv_11= '<' ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) ) (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )* otherlv_15= '>'
+            	            {
+            	            otherlv_11=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              						newLeafNode(otherlv_11, grammarAccess.getXMemberFeatureCallAccess().getLessThanSignKeyword_1_1_1_0());
+            	              					
+            	            }
+            	            // InternalOXtype.g:2484:6: ( (lv_typeArguments_12_0= ruleJvmArgumentTypeReference ) )
+            	            // InternalOXtype.g:2485:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference )
+            	            {
+            	            // InternalOXtype.g:2485:7: (lv_typeArguments_12_0= ruleJvmArgumentTypeReference )
+            	            // InternalOXtype.g:2486:8: lv_typeArguments_12_0= ruleJvmArgumentTypeReference
+            	            {
+            	            if ( state.backtracking==0 ) {
+
+            	              								newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_1_0());
+            	              							
+            	            }
+            	            pushFollow(FOLLOW_39);
+            	            lv_typeArguments_12_0=ruleJvmArgumentTypeReference();
+
+            	            state._fsp--;
+            	            if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              								if (current==null) {
+            	              									current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	              								}
+            	              								add(
+            	              									current,
+            	              									"typeArguments",
+            	              									lv_typeArguments_12_0,
+            	              									"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+            	              								afterParserOrEnumRuleCall();
+            	              							
+            	            }
+
+            	            }
+
+
+            	            }
+
+            	            // InternalOXtype.g:2503:6: (otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) ) )*
+            	            loop42:
+            	            do {
+            	                int alt42=2;
+            	                int LA42_0 = input.LA(1);
+
+            	                if ( (LA42_0==21) ) {
+            	                    alt42=1;
+            	                }
+
+
+            	                switch (alt42) {
+            	            	case 1 :
+            	            	    // InternalOXtype.g:2504:7: otherlv_13= ',' ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) )
+            	            	    {
+            	            	    otherlv_13=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+            	            	    if ( state.backtracking==0 ) {
+
+            	            	      							newLeafNode(otherlv_13, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_1_2_0());
+            	            	      						
+            	            	    }
+            	            	    // InternalOXtype.g:2508:7: ( (lv_typeArguments_14_0= ruleJvmArgumentTypeReference ) )
+            	            	    // InternalOXtype.g:2509:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference )
+            	            	    {
+            	            	    // InternalOXtype.g:2509:8: (lv_typeArguments_14_0= ruleJvmArgumentTypeReference )
+            	            	    // InternalOXtype.g:2510:9: lv_typeArguments_14_0= ruleJvmArgumentTypeReference
+            	            	    {
+            	            	    if ( state.backtracking==0 ) {
+
+            	            	      									newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_1_2_1_0());
+            	            	      								
+            	            	    }
+            	            	    pushFollow(FOLLOW_39);
+            	            	    lv_typeArguments_14_0=ruleJvmArgumentTypeReference();
+
+            	            	    state._fsp--;
+            	            	    if (state.failed) return current;
+            	            	    if ( state.backtracking==0 ) {
+
+            	            	      									if (current==null) {
+            	            	      										current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	            	      									}
+            	            	      									add(
+            	            	      										current,
+            	            	      										"typeArguments",
+            	            	      										lv_typeArguments_14_0,
+            	            	      										"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+            	            	      									afterParserOrEnumRuleCall();
+            	            	      								
+            	            	    }
+
+            	            	    }
+
+
+            	            	    }
+
+
+            	            	    }
+            	            	    break;
+
+            	            	default :
+            	            	    break loop42;
+            	                }
+            	            } while (true);
+
+            	            otherlv_15=(Token)match(input,33,FOLLOW_37); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              						newLeafNode(otherlv_15, grammarAccess.getXMemberFeatureCallAccess().getGreaterThanSignKeyword_1_1_1_3());
+            	              					
+            	            }
+
+            	            }
+            	            break;
+
+            	    }
+
+            	    // InternalOXtype.g:2533:5: ( ( ruleIdOrSuper ) )
+            	    // InternalOXtype.g:2534:6: ( ruleIdOrSuper )
+            	    {
+            	    // InternalOXtype.g:2534:6: ( ruleIdOrSuper )
+            	    // InternalOXtype.g:2535:7: ruleIdOrSuper
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      							if (current==null) {
+            	      								current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+            	      							}
+            	      						
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_1_1_2_0());
+            	      						
+            	    }
+            	    pushFollow(FOLLOW_40);
+            	    ruleIdOrSuper();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      							afterParserOrEnumRuleCall();
+            	      						
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:2549:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?
+            	    int alt46=2;
+            	    alt46 = dfa46.predict(input);
+            	    switch (alt46) {
+            	        case 1 :
+            	            // InternalOXtype.g:2550:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')'
+            	            {
+            	            // InternalOXtype.g:2550:6: ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) )
+            	            // InternalOXtype.g:2551:7: ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' )
+            	            {
+            	            // InternalOXtype.g:2555:7: (lv_explicitOperationCall_17_0= '(' )
+            	            // InternalOXtype.g:2556:8: lv_explicitOperationCall_17_0= '('
+            	            {
+            	            lv_explicitOperationCall_17_0=(Token)match(input,20,FOLLOW_41); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              								newLeafNode(lv_explicitOperationCall_17_0, grammarAccess.getXMemberFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_1_1_3_0_0());
+            	              							
+            	            }
+            	            if ( state.backtracking==0 ) {
+
+            	              								if (current==null) {
+            	              									current = createModelElement(grammarAccess.getXMemberFeatureCallRule());
+            	              								}
+            	              								setWithLastConsumed(current, "explicitOperationCall", true, "(");
+            	              							
+            	            }
+
+            	            }
+
+
+            	            }
+
+            	            // InternalOXtype.g:2568:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?
+            	            int alt45=3;
+            	            alt45 = dfa45.predict(input);
+            	            switch (alt45) {
+            	                case 1 :
+            	                    // InternalOXtype.g:2569:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) )
+            	                    {
+            	                    // InternalOXtype.g:2569:7: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) )
+            	                    // InternalOXtype.g:2570:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure )
+            	                    {
+            	                    // InternalOXtype.g:2595:8: (lv_memberCallArguments_18_0= ruleXShortClosure )
+            	                    // InternalOXtype.g:2596:9: lv_memberCallArguments_18_0= ruleXShortClosure
+            	                    {
+            	                    if ( state.backtracking==0 ) {
+
+            	                      									newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXShortClosureParserRuleCall_1_1_3_1_0_0());
+            	                      								
+            	                    }
+            	                    pushFollow(FOLLOW_11);
+            	                    lv_memberCallArguments_18_0=ruleXShortClosure();
+
+            	                    state._fsp--;
+            	                    if (state.failed) return current;
+            	                    if ( state.backtracking==0 ) {
+
+            	                      									if (current==null) {
+            	                      										current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	                      									}
+            	                      									add(
+            	                      										current,
+            	                      										"memberCallArguments",
+            	                      										lv_memberCallArguments_18_0,
+            	                      										"org.eclipse.xtext.xbase.Xbase.XShortClosure");
+            	                      									afterParserOrEnumRuleCall();
+            	                      								
+            	                    }
+
+            	                    }
+
+
+            	                    }
+
+
+            	                    }
+            	                    break;
+            	                case 2 :
+            	                    // InternalOXtype.g:2614:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* )
+            	                    {
+            	                    // InternalOXtype.g:2614:7: ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* )
+            	                    // InternalOXtype.g:2615:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )*
+            	                    {
+            	                    // InternalOXtype.g:2615:8: ( (lv_memberCallArguments_19_0= ruleXExpression ) )
+            	                    // InternalOXtype.g:2616:9: (lv_memberCallArguments_19_0= ruleXExpression )
+            	                    {
+            	                    // InternalOXtype.g:2616:9: (lv_memberCallArguments_19_0= ruleXExpression )
+            	                    // InternalOXtype.g:2617:10: lv_memberCallArguments_19_0= ruleXExpression
+            	                    {
+            	                    if ( state.backtracking==0 ) {
+
+            	                      										newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_0_0());
+            	                      									
+            	                    }
+            	                    pushFollow(FOLLOW_10);
+            	                    lv_memberCallArguments_19_0=ruleXExpression();
+
+            	                    state._fsp--;
+            	                    if (state.failed) return current;
+            	                    if ( state.backtracking==0 ) {
+
+            	                      										if (current==null) {
+            	                      											current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	                      										}
+            	                      										add(
+            	                      											current,
+            	                      											"memberCallArguments",
+            	                      											lv_memberCallArguments_19_0,
+            	                      											"org.eclipse.xtext.xbase.Xbase.XExpression");
+            	                      										afterParserOrEnumRuleCall();
+            	                      									
+            	                    }
+
+            	                    }
+
+
+            	                    }
+
+            	                    // InternalOXtype.g:2634:8: (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )*
+            	                    loop44:
+            	                    do {
+            	                        int alt44=2;
+            	                        int LA44_0 = input.LA(1);
+
+            	                        if ( (LA44_0==21) ) {
+            	                            alt44=1;
+            	                        }
+
+
+            	                        switch (alt44) {
+            	                    	case 1 :
+            	                    	    // InternalOXtype.g:2635:9: otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) )
+            	                    	    {
+            	                    	    otherlv_20=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+            	                    	    if ( state.backtracking==0 ) {
+
+            	                    	      									newLeafNode(otherlv_20, grammarAccess.getXMemberFeatureCallAccess().getCommaKeyword_1_1_3_1_1_1_0());
+            	                    	      								
+            	                    	    }
+            	                    	    // InternalOXtype.g:2639:9: ( (lv_memberCallArguments_21_0= ruleXExpression ) )
+            	                    	    // InternalOXtype.g:2640:10: (lv_memberCallArguments_21_0= ruleXExpression )
+            	                    	    {
+            	                    	    // InternalOXtype.g:2640:10: (lv_memberCallArguments_21_0= ruleXExpression )
+            	                    	    // InternalOXtype.g:2641:11: lv_memberCallArguments_21_0= ruleXExpression
+            	                    	    {
+            	                    	    if ( state.backtracking==0 ) {
+
+            	                    	      											newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXExpressionParserRuleCall_1_1_3_1_1_1_1_0());
+            	                    	      										
+            	                    	    }
+            	                    	    pushFollow(FOLLOW_10);
+            	                    	    lv_memberCallArguments_21_0=ruleXExpression();
+
+            	                    	    state._fsp--;
+            	                    	    if (state.failed) return current;
+            	                    	    if ( state.backtracking==0 ) {
+
+            	                    	      											if (current==null) {
+            	                    	      												current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	                    	      											}
+            	                    	      											add(
+            	                    	      												current,
+            	                    	      												"memberCallArguments",
+            	                    	      												lv_memberCallArguments_21_0,
+            	                    	      												"org.eclipse.xtext.xbase.Xbase.XExpression");
+            	                    	      											afterParserOrEnumRuleCall();
+            	                    	      										
+            	                    	    }
+
+            	                    	    }
+
+
+            	                    	    }
+
+
+            	                    	    }
+            	                    	    break;
+
+            	                    	default :
+            	                    	    break loop44;
+            	                        }
+            	                    } while (true);
+
+
+            	                    }
+
+
+            	                    }
+            	                    break;
+
+            	            }
+
+            	            otherlv_22=(Token)match(input,22,FOLLOW_42); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              						newLeafNode(otherlv_22, grammarAccess.getXMemberFeatureCallAccess().getRightParenthesisKeyword_1_1_3_2());
+            	              					
+            	            }
+
+            	            }
+            	            break;
+
+            	    }
+
+            	    // InternalOXtype.g:2666:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?
+            	    int alt47=2;
+            	    alt47 = dfa47.predict(input);
+            	    switch (alt47) {
+            	        case 1 :
+            	            // InternalOXtype.g:2667:6: ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure )
+            	            {
+            	            // InternalOXtype.g:2673:6: (lv_memberCallArguments_23_0= ruleXClosure )
+            	            // InternalOXtype.g:2674:7: lv_memberCallArguments_23_0= ruleXClosure
+            	            {
+            	            if ( state.backtracking==0 ) {
+
+            	              							newCompositeNode(grammarAccess.getXMemberFeatureCallAccess().getMemberCallArgumentsXClosureParserRuleCall_1_1_4_0());
+            	              						
+            	            }
+            	            pushFollow(FOLLOW_35);
+            	            lv_memberCallArguments_23_0=ruleXClosure();
+
+            	            state._fsp--;
+            	            if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              							if (current==null) {
+            	              								current = createModelElementForParent(grammarAccess.getXMemberFeatureCallRule());
+            	              							}
+            	              							add(
+            	              								current,
+            	              								"memberCallArguments",
+            	              								lv_memberCallArguments_23_0,
+            	              								"org.eclipse.xtext.xbase.Xbase.XClosure");
+            	              							afterParserOrEnumRuleCall();
+            	              						
+            	            }
+
+            	            }
+
+
+            	            }
+            	            break;
+
+            	    }
+
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop48;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXMemberFeatureCall"
+
+
+    // $ANTLR start "entryRuleXPrimaryExpression"
+    // InternalOXtype.g:2697:1: entryRuleXPrimaryExpression returns [EObject current=null] : iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF ;
+    public final EObject entryRuleXPrimaryExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXPrimaryExpression = null;
+
+
+        try {
+            // InternalOXtype.g:2697:59: (iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF )
+            // InternalOXtype.g:2698:2: iv_ruleXPrimaryExpression= ruleXPrimaryExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXPrimaryExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXPrimaryExpression=ruleXPrimaryExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXPrimaryExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXPrimaryExpression"
+
+
+    // $ANTLR start "ruleXPrimaryExpression"
+    // InternalOXtype.g:2704:1: ruleXPrimaryExpression returns [EObject current=null] : (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) ;
+    public final EObject ruleXPrimaryExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XConstructorCall_0 = null;
+
+        EObject this_XBlockExpression_1 = null;
+
+        EObject this_XSwitchExpression_2 = null;
+
+        EObject this_XSynchronizedExpression_3 = null;
+
+        EObject this_XFeatureCall_4 = null;
+
+        EObject this_XLiteral_5 = null;
+
+        EObject this_XIfExpression_6 = null;
+
+        EObject this_XForLoopExpression_7 = null;
+
+        EObject this_XBasicForLoopExpression_8 = null;
+
+        EObject this_XWhileExpression_9 = null;
+
+        EObject this_XDoWhileExpression_10 = null;
+
+        EObject this_XThrowExpression_11 = null;
+
+        EObject this_XReturnExpression_12 = null;
+
+        EObject this_XTryCatchFinallyExpression_13 = null;
+
+        EObject this_XParenthesizedExpression_14 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2710:2: ( (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression ) )
+            // InternalOXtype.g:2711:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )
+            {
+            // InternalOXtype.g:2711:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )
+            int alt49=15;
+            alt49 = dfa49.predict(input);
+            switch (alt49) {
+                case 1 :
+                    // InternalOXtype.g:2712:3: this_XConstructorCall_0= ruleXConstructorCall
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXConstructorCallParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XConstructorCall_0=ruleXConstructorCall();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XConstructorCall_0;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2721:3: this_XBlockExpression_1= ruleXBlockExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBlockExpressionParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XBlockExpression_1=ruleXBlockExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XBlockExpression_1;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2730:3: this_XSwitchExpression_2= ruleXSwitchExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSwitchExpressionParserRuleCall_2());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XSwitchExpression_2=ruleXSwitchExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XSwitchExpression_2;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2739:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression )
+                    {
+                    // InternalOXtype.g:2739:3: ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression )
+                    // InternalOXtype.g:2740:4: ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXSynchronizedExpressionParserRuleCall_3());
+                      			
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XSynchronizedExpression_3=ruleXSynchronizedExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current = this_XSynchronizedExpression_3;
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:2757:3: this_XFeatureCall_4= ruleXFeatureCall
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXFeatureCallParserRuleCall_4());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XFeatureCall_4=ruleXFeatureCall();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XFeatureCall_4;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:2766:3: this_XLiteral_5= ruleXLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXLiteralParserRuleCall_5());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XLiteral_5=ruleXLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XLiteral_5;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:2775:3: this_XIfExpression_6= ruleXIfExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXIfExpressionParserRuleCall_6());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XIfExpression_6=ruleXIfExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XIfExpression_6;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 8 :
+                    // InternalOXtype.g:2784:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression )
+                    {
+                    // InternalOXtype.g:2784:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression )
+                    // InternalOXtype.g:2785:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXForLoopExpressionParserRuleCall_7());
+                      			
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XForLoopExpression_7=ruleXForLoopExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current = this_XForLoopExpression_7;
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 9 :
+                    // InternalOXtype.g:2808:3: this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXBasicForLoopExpressionParserRuleCall_8());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XBasicForLoopExpression_8=ruleXBasicForLoopExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XBasicForLoopExpression_8;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 10 :
+                    // InternalOXtype.g:2817:3: this_XWhileExpression_9= ruleXWhileExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXWhileExpressionParserRuleCall_9());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XWhileExpression_9=ruleXWhileExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XWhileExpression_9;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 11 :
+                    // InternalOXtype.g:2826:3: this_XDoWhileExpression_10= ruleXDoWhileExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXDoWhileExpressionParserRuleCall_10());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XDoWhileExpression_10=ruleXDoWhileExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XDoWhileExpression_10;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 12 :
+                    // InternalOXtype.g:2835:3: this_XThrowExpression_11= ruleXThrowExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXThrowExpressionParserRuleCall_11());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XThrowExpression_11=ruleXThrowExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XThrowExpression_11;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 13 :
+                    // InternalOXtype.g:2844:3: this_XReturnExpression_12= ruleXReturnExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXReturnExpressionParserRuleCall_12());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XReturnExpression_12=ruleXReturnExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XReturnExpression_12;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 14 :
+                    // InternalOXtype.g:2853:3: this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXTryCatchFinallyExpressionParserRuleCall_13());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XTryCatchFinallyExpression_13=ruleXTryCatchFinallyExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XTryCatchFinallyExpression_13;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 15 :
+                    // InternalOXtype.g:2862:3: this_XParenthesizedExpression_14= ruleXParenthesizedExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXPrimaryExpressionAccess().getXParenthesizedExpressionParserRuleCall_14());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XParenthesizedExpression_14=ruleXParenthesizedExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XParenthesizedExpression_14;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXPrimaryExpression"
+
+
+    // $ANTLR start "entryRuleXLiteral"
+    // InternalOXtype.g:2874:1: entryRuleXLiteral returns [EObject current=null] : iv_ruleXLiteral= ruleXLiteral EOF ;
+    public final EObject entryRuleXLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:2874:49: (iv_ruleXLiteral= ruleXLiteral EOF )
+            // InternalOXtype.g:2875:2: iv_ruleXLiteral= ruleXLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXLiteral=ruleXLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXLiteral"
+
+
+    // $ANTLR start "ruleXLiteral"
+    // InternalOXtype.g:2881:1: ruleXLiteral returns [EObject current=null] : (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) ;
+    public final EObject ruleXLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XCollectionLiteral_0 = null;
+
+        EObject this_XClosure_1 = null;
+
+        EObject this_XBooleanLiteral_2 = null;
+
+        EObject this_XNumberLiteral_3 = null;
+
+        EObject this_XNullLiteral_4 = null;
+
+        EObject this_XStringLiteral_5 = null;
+
+        EObject this_XTypeLiteral_6 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2887:2: ( (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral ) )
+            // InternalOXtype.g:2888:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral )
+            {
+            // InternalOXtype.g:2888:2: (this_XCollectionLiteral_0= ruleXCollectionLiteral | ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure ) | this_XBooleanLiteral_2= ruleXBooleanLiteral | this_XNumberLiteral_3= ruleXNumberLiteral | this_XNullLiteral_4= ruleXNullLiteral | this_XStringLiteral_5= ruleXStringLiteral | this_XTypeLiteral_6= ruleXTypeLiteral )
+            int alt50=7;
+            int LA50_0 = input.LA(1);
+
+            if ( (LA50_0==24) ) {
+                alt50=1;
+            }
+            else if ( (LA50_0==25) && (synpred27_InternalOXtype())) {
+                alt50=2;
+            }
+            else if ( ((LA50_0>=77 && LA50_0<=78)) ) {
+                alt50=3;
+            }
+            else if ( ((LA50_0>=RULE_HEX && LA50_0<=RULE_DECIMAL)) ) {
+                alt50=4;
+            }
+            else if ( (LA50_0==79) ) {
+                alt50=5;
+            }
+            else if ( (LA50_0==RULE_STRING) ) {
+                alt50=6;
+            }
+            else if ( (LA50_0==80) ) {
+                alt50=7;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 50, 0, input);
+
+                throw nvae;
+            }
+            switch (alt50) {
+                case 1 :
+                    // InternalOXtype.g:2889:3: this_XCollectionLiteral_0= ruleXCollectionLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXLiteralAccess().getXCollectionLiteralParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XCollectionLiteral_0=ruleXCollectionLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XCollectionLiteral_0;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2898:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure )
+                    {
+                    // InternalOXtype.g:2898:3: ( ( ( () '[' ) )=>this_XClosure_1= ruleXClosure )
+                    // InternalOXtype.g:2899:4: ( ( () '[' ) )=>this_XClosure_1= ruleXClosure
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getXLiteralAccess().getXClosureParserRuleCall_1());
+                      			
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XClosure_1=ruleXClosure();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current = this_XClosure_1;
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:2915:3: this_XBooleanLiteral_2= ruleXBooleanLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXLiteralAccess().getXBooleanLiteralParserRuleCall_2());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XBooleanLiteral_2=ruleXBooleanLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XBooleanLiteral_2;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:2924:3: this_XNumberLiteral_3= ruleXNumberLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXLiteralAccess().getXNumberLiteralParserRuleCall_3());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XNumberLiteral_3=ruleXNumberLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XNumberLiteral_3;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:2933:3: this_XNullLiteral_4= ruleXNullLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXLiteralAccess().getXNullLiteralParserRuleCall_4());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XNullLiteral_4=ruleXNullLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XNullLiteral_4;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 6 :
+                    // InternalOXtype.g:2942:3: this_XStringLiteral_5= ruleXStringLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXLiteralAccess().getXStringLiteralParserRuleCall_5());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XStringLiteral_5=ruleXStringLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XStringLiteral_5;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 7 :
+                    // InternalOXtype.g:2951:3: this_XTypeLiteral_6= ruleXTypeLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXLiteralAccess().getXTypeLiteralParserRuleCall_6());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XTypeLiteral_6=ruleXTypeLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XTypeLiteral_6;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXLiteral"
+
+
+    // $ANTLR start "entryRuleXCollectionLiteral"
+    // InternalOXtype.g:2963:1: entryRuleXCollectionLiteral returns [EObject current=null] : iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF ;
+    public final EObject entryRuleXCollectionLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXCollectionLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:2963:59: (iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF )
+            // InternalOXtype.g:2964:2: iv_ruleXCollectionLiteral= ruleXCollectionLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXCollectionLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXCollectionLiteral=ruleXCollectionLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXCollectionLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXCollectionLiteral"
+
+
+    // $ANTLR start "ruleXCollectionLiteral"
+    // InternalOXtype.g:2970:1: ruleXCollectionLiteral returns [EObject current=null] : (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) ;
+    public final EObject ruleXCollectionLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XSetLiteral_0 = null;
+
+        EObject this_XListLiteral_1 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:2976:2: ( (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral ) )
+            // InternalOXtype.g:2977:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral )
+            {
+            // InternalOXtype.g:2977:2: (this_XSetLiteral_0= ruleXSetLiteral | this_XListLiteral_1= ruleXListLiteral )
+            int alt51=2;
+            int LA51_0 = input.LA(1);
+
+            if ( (LA51_0==24) ) {
+                int LA51_1 = input.LA(2);
+
+                if ( (LA51_1==60) ) {
+                    alt51=1;
+                }
+                else if ( (LA51_1==25) ) {
+                    alt51=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 51, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 51, 0, input);
+
+                throw nvae;
+            }
+            switch (alt51) {
+                case 1 :
+                    // InternalOXtype.g:2978:3: this_XSetLiteral_0= ruleXSetLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXSetLiteralParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XSetLiteral_0=ruleXSetLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XSetLiteral_0;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:2987:3: this_XListLiteral_1= ruleXListLiteral
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXCollectionLiteralAccess().getXListLiteralParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XListLiteral_1=ruleXListLiteral();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XListLiteral_1;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXCollectionLiteral"
+
+
+    // $ANTLR start "entryRuleXSetLiteral"
+    // InternalOXtype.g:2999:1: entryRuleXSetLiteral returns [EObject current=null] : iv_ruleXSetLiteral= ruleXSetLiteral EOF ;
+    public final EObject entryRuleXSetLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXSetLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:2999:52: (iv_ruleXSetLiteral= ruleXSetLiteral EOF )
+            // InternalOXtype.g:3000:2: iv_ruleXSetLiteral= ruleXSetLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXSetLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXSetLiteral=ruleXSetLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXSetLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXSetLiteral"
+
+
+    // $ANTLR start "ruleXSetLiteral"
+    // InternalOXtype.g:3006:1: ruleXSetLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) ;
+    public final EObject ruleXSetLiteral() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_elements_3_0 = null;
+
+        EObject lv_elements_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3012:2: ( ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' ) )
+            // InternalOXtype.g:3013:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' )
+            {
+            // InternalOXtype.g:3013:2: ( () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}' )
+            // InternalOXtype.g:3014:3: () otherlv_1= '#' otherlv_2= '{' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= '}'
+            {
+            // InternalOXtype.g:3014:3: ()
+            // InternalOXtype.g:3015:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXSetLiteralAccess().getXSetLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,24,FOLLOW_43); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXSetLiteralAccess().getNumberSignKeyword_1());
+              		
+            }
+            otherlv_2=(Token)match(input,60,FOLLOW_44); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXSetLiteralAccess().getLeftCurlyBracketKeyword_2());
+              		
+            }
+            // InternalOXtype.g:3029:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )?
+            int alt53=2;
+            int LA53_0 = input.LA(1);
+
+            if ( ((LA53_0>=RULE_STRING && LA53_0<=RULE_ID)||(LA53_0>=13 && LA53_0<=15)||LA53_0==20||(LA53_0>=24 && LA53_0<=25)||LA53_0==32||(LA53_0>=48 && LA53_0<=49)||LA53_0==53||LA53_0==60||LA53_0==63||LA53_0==65||(LA53_0>=69 && LA53_0<=71)||(LA53_0>=74 && LA53_0<=83)||LA53_0==85) ) {
+                alt53=1;
+            }
+            switch (alt53) {
+                case 1 :
+                    // InternalOXtype.g:3030:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+                    {
+                    // InternalOXtype.g:3030:4: ( (lv_elements_3_0= ruleXExpression ) )
+                    // InternalOXtype.g:3031:5: (lv_elements_3_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3031:5: (lv_elements_3_0= ruleXExpression )
+                    // InternalOXtype.g:3032:6: lv_elements_3_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_45);
+                    lv_elements_3_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+                      						}
+                      						add(
+                      							current,
+                      							"elements",
+                      							lv_elements_3_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:3049:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+                    loop52:
+                    do {
+                        int alt52=2;
+                        int LA52_0 = input.LA(1);
+
+                        if ( (LA52_0==21) ) {
+                            alt52=1;
+                        }
+
+
+                        switch (alt52) {
+                    	case 1 :
+                    	    // InternalOXtype.g:3050:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) )
+                    	    {
+                    	    otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_4, grammarAccess.getXSetLiteralAccess().getCommaKeyword_3_1_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:3054:5: ( (lv_elements_5_0= ruleXExpression ) )
+                    	    // InternalOXtype.g:3055:6: (lv_elements_5_0= ruleXExpression )
+                    	    {
+                    	    // InternalOXtype.g:3055:6: (lv_elements_5_0= ruleXExpression )
+                    	    // InternalOXtype.g:3056:7: lv_elements_5_0= ruleXExpression
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXSetLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_45);
+                    	    lv_elements_5_0=ruleXExpression();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXSetLiteralRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"elements",
+                    	      								lv_elements_5_0,
+                    	      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop52;
+                        }
+                    } while (true);
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_6=(Token)match(input,61,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_6, grammarAccess.getXSetLiteralAccess().getRightCurlyBracketKeyword_4());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXSetLiteral"
+
+
+    // $ANTLR start "entryRuleXListLiteral"
+    // InternalOXtype.g:3083:1: entryRuleXListLiteral returns [EObject current=null] : iv_ruleXListLiteral= ruleXListLiteral EOF ;
+    public final EObject entryRuleXListLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXListLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:3083:53: (iv_ruleXListLiteral= ruleXListLiteral EOF )
+            // InternalOXtype.g:3084:2: iv_ruleXListLiteral= ruleXListLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXListLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXListLiteral=ruleXListLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXListLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXListLiteral"
+
+
+    // $ANTLR start "ruleXListLiteral"
+    // InternalOXtype.g:3090:1: ruleXListLiteral returns [EObject current=null] : ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) ;
+    public final EObject ruleXListLiteral() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_elements_3_0 = null;
+
+        EObject lv_elements_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3096:2: ( ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' ) )
+            // InternalOXtype.g:3097:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' )
+            {
+            // InternalOXtype.g:3097:2: ( () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']' )
+            // InternalOXtype.g:3098:3: () otherlv_1= '#' otherlv_2= '[' ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )? otherlv_6= ']'
+            {
+            // InternalOXtype.g:3098:3: ()
+            // InternalOXtype.g:3099:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXListLiteralAccess().getXListLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,24,FOLLOW_14); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXListLiteralAccess().getNumberSignKeyword_1());
+              		
+            }
+            otherlv_2=(Token)match(input,25,FOLLOW_15); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXListLiteralAccess().getLeftSquareBracketKeyword_2());
+              		
+            }
+            // InternalOXtype.g:3113:3: ( ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )* )?
+            int alt55=2;
+            int LA55_0 = input.LA(1);
+
+            if ( ((LA55_0>=RULE_STRING && LA55_0<=RULE_ID)||(LA55_0>=13 && LA55_0<=15)||LA55_0==20||(LA55_0>=24 && LA55_0<=25)||LA55_0==32||(LA55_0>=48 && LA55_0<=49)||LA55_0==53||LA55_0==60||LA55_0==63||LA55_0==65||(LA55_0>=69 && LA55_0<=71)||(LA55_0>=74 && LA55_0<=83)||LA55_0==85) ) {
+                alt55=1;
+            }
+            switch (alt55) {
+                case 1 :
+                    // InternalOXtype.g:3114:4: ( (lv_elements_3_0= ruleXExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+                    {
+                    // InternalOXtype.g:3114:4: ( (lv_elements_3_0= ruleXExpression ) )
+                    // InternalOXtype.g:3115:5: (lv_elements_3_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3115:5: (lv_elements_3_0= ruleXExpression )
+                    // InternalOXtype.g:3116:6: lv_elements_3_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_0_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_16);
+                    lv_elements_3_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+                      						}
+                      						add(
+                      							current,
+                      							"elements",
+                      							lv_elements_3_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:3133:4: (otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) ) )*
+                    loop54:
+                    do {
+                        int alt54=2;
+                        int LA54_0 = input.LA(1);
+
+                        if ( (LA54_0==21) ) {
+                            alt54=1;
+                        }
+
+
+                        switch (alt54) {
+                    	case 1 :
+                    	    // InternalOXtype.g:3134:5: otherlv_4= ',' ( (lv_elements_5_0= ruleXExpression ) )
+                    	    {
+                    	    otherlv_4=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_4, grammarAccess.getXListLiteralAccess().getCommaKeyword_3_1_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:3138:5: ( (lv_elements_5_0= ruleXExpression ) )
+                    	    // InternalOXtype.g:3139:6: (lv_elements_5_0= ruleXExpression )
+                    	    {
+                    	    // InternalOXtype.g:3139:6: (lv_elements_5_0= ruleXExpression )
+                    	    // InternalOXtype.g:3140:7: lv_elements_5_0= ruleXExpression
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXListLiteralAccess().getElementsXExpressionParserRuleCall_3_1_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_16);
+                    	    lv_elements_5_0=ruleXExpression();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXListLiteralRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"elements",
+                    	      								lv_elements_5_0,
+                    	      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop54;
+                        }
+                    } while (true);
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_6=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_6, grammarAccess.getXListLiteralAccess().getRightSquareBracketKeyword_4());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXListLiteral"
+
+
+    // $ANTLR start "entryRuleXClosure"
+    // InternalOXtype.g:3167:1: entryRuleXClosure returns [EObject current=null] : iv_ruleXClosure= ruleXClosure EOF ;
+    public final EObject entryRuleXClosure() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXClosure = null;
+
+
+        try {
+            // InternalOXtype.g:3167:49: (iv_ruleXClosure= ruleXClosure EOF )
+            // InternalOXtype.g:3168:2: iv_ruleXClosure= ruleXClosure EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXClosureRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXClosure=ruleXClosure();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXClosure; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXClosure"
+
+
+    // $ANTLR start "ruleXClosure"
+    // InternalOXtype.g:3174:1: ruleXClosure returns [EObject current=null] : ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) ;
+    public final EObject ruleXClosure() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token lv_explicitSyntax_5_0=null;
+        Token otherlv_7=null;
+        EObject lv_declaredFormalParameters_2_0 = null;
+
+        EObject lv_declaredFormalParameters_4_0 = null;
+
+        EObject lv_expression_6_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3180:2: ( ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' ) )
+            // InternalOXtype.g:3181:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' )
+            {
+            // InternalOXtype.g:3181:2: ( ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']' )
+            // InternalOXtype.g:3182:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) ) ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )? ( (lv_expression_6_0= ruleXExpressionInClosure ) ) otherlv_7= ']'
+            {
+            // InternalOXtype.g:3182:3: ( ( ( () '[' ) )=> ( () otherlv_1= '[' ) )
+            // InternalOXtype.g:3183:4: ( ( () '[' ) )=> ( () otherlv_1= '[' )
+            {
+            // InternalOXtype.g:3189:4: ( () otherlv_1= '[' )
+            // InternalOXtype.g:3190:5: () otherlv_1= '['
+            {
+            // InternalOXtype.g:3190:5: ()
+            // InternalOXtype.g:3191:6: 
+            {
+            if ( state.backtracking==0 ) {
+
+              						current = forceCreateModelElement(
+              							grammarAccess.getXClosureAccess().getXClosureAction_0_0_0(),
+              							current);
+              					
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,25,FOLLOW_46); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_1, grammarAccess.getXClosureAccess().getLeftSquareBracketKeyword_0_0_1());
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:3203:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?
+            int alt58=2;
+            alt58 = dfa58.predict(input);
+            switch (alt58) {
+                case 1 :
+                    // InternalOXtype.g:3204:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) )
+                    {
+                    // InternalOXtype.g:3227:4: ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) )
+                    // InternalOXtype.g:3228:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) )
+                    {
+                    // InternalOXtype.g:3228:5: ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )?
+                    int alt57=2;
+                    int LA57_0 = input.LA(1);
+
+                    if ( (LA57_0==RULE_ID||LA57_0==20||LA57_0==45) ) {
+                        alt57=1;
+                    }
+                    switch (alt57) {
+                        case 1 :
+                            // InternalOXtype.g:3229:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )*
+                            {
+                            // InternalOXtype.g:3229:6: ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) )
+                            // InternalOXtype.g:3230:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter )
+                            {
+                            // InternalOXtype.g:3230:7: (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter )
+                            // InternalOXtype.g:3231:8: lv_declaredFormalParameters_2_0= ruleJvmFormalParameter
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_0_0());
+                              							
+                            }
+                            pushFollow(FOLLOW_47);
+                            lv_declaredFormalParameters_2_0=ruleJvmFormalParameter();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElementForParent(grammarAccess.getXClosureRule());
+                              								}
+                              								add(
+                              									current,
+                              									"declaredFormalParameters",
+                              									lv_declaredFormalParameters_2_0,
+                              									"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+                              								afterParserOrEnumRuleCall();
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:3248:6: (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )*
+                            loop56:
+                            do {
+                                int alt56=2;
+                                int LA56_0 = input.LA(1);
+
+                                if ( (LA56_0==21) ) {
+                                    alt56=1;
+                                }
+
+
+                                switch (alt56) {
+                            	case 1 :
+                            	    // InternalOXtype.g:3249:7: otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) )
+                            	    {
+                            	    otherlv_3=(Token)match(input,21,FOLLOW_26); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      							newLeafNode(otherlv_3, grammarAccess.getXClosureAccess().getCommaKeyword_1_0_0_1_0());
+                            	      						
+                            	    }
+                            	    // InternalOXtype.g:3253:7: ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) )
+                            	    // InternalOXtype.g:3254:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter )
+                            	    {
+                            	    // InternalOXtype.g:3254:8: (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter )
+                            	    // InternalOXtype.g:3255:9: lv_declaredFormalParameters_4_0= ruleJvmFormalParameter
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									newCompositeNode(grammarAccess.getXClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_1_0_0_1_1_0());
+                            	      								
+                            	    }
+                            	    pushFollow(FOLLOW_47);
+                            	    lv_declaredFormalParameters_4_0=ruleJvmFormalParameter();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									if (current==null) {
+                            	      										current = createModelElementForParent(grammarAccess.getXClosureRule());
+                            	      									}
+                            	      									add(
+                            	      										current,
+                            	      										"declaredFormalParameters",
+                            	      										lv_declaredFormalParameters_4_0,
+                            	      										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+                            	      									afterParserOrEnumRuleCall();
+                            	      								
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop56;
+                                }
+                            } while (true);
+
+
+                            }
+                            break;
+
+                    }
+
+                    // InternalOXtype.g:3274:5: ( (lv_explicitSyntax_5_0= '|' ) )
+                    // InternalOXtype.g:3275:6: (lv_explicitSyntax_5_0= '|' )
+                    {
+                    // InternalOXtype.g:3275:6: (lv_explicitSyntax_5_0= '|' )
+                    // InternalOXtype.g:3276:7: lv_explicitSyntax_5_0= '|'
+                    {
+                    lv_explicitSyntax_5_0=(Token)match(input,62,FOLLOW_48); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							newLeafNode(lv_explicitSyntax_5_0, grammarAccess.getXClosureAccess().getExplicitSyntaxVerticalLineKeyword_1_0_1_0());
+                      						
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElement(grammarAccess.getXClosureRule());
+                      							}
+                      							setWithLastConsumed(current, "explicitSyntax", true, "|");
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:3290:3: ( (lv_expression_6_0= ruleXExpressionInClosure ) )
+            // InternalOXtype.g:3291:4: (lv_expression_6_0= ruleXExpressionInClosure )
+            {
+            // InternalOXtype.g:3291:4: (lv_expression_6_0= ruleXExpressionInClosure )
+            // InternalOXtype.g:3292:5: lv_expression_6_0= ruleXExpressionInClosure
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXClosureAccess().getExpressionXExpressionInClosureParserRuleCall_2_0());
+              				
+            }
+            pushFollow(FOLLOW_49);
+            lv_expression_6_0=ruleXExpressionInClosure();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXClosureRule());
+              					}
+              					set(
+              						current,
+              						"expression",
+              						lv_expression_6_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpressionInClosure");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_7=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_7, grammarAccess.getXClosureAccess().getRightSquareBracketKeyword_3());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXClosure"
+
+
+    // $ANTLR start "entryRuleXExpressionInClosure"
+    // InternalOXtype.g:3317:1: entryRuleXExpressionInClosure returns [EObject current=null] : iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF ;
+    public final EObject entryRuleXExpressionInClosure() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXExpressionInClosure = null;
+
+
+        try {
+            // InternalOXtype.g:3317:61: (iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF )
+            // InternalOXtype.g:3318:2: iv_ruleXExpressionInClosure= ruleXExpressionInClosure EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXExpressionInClosureRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXExpressionInClosure=ruleXExpressionInClosure();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXExpressionInClosure; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXExpressionInClosure"
+
+
+    // $ANTLR start "ruleXExpressionInClosure"
+    // InternalOXtype.g:3324:1: ruleXExpressionInClosure returns [EObject current=null] : ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) ;
+    public final EObject ruleXExpressionInClosure() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_2=null;
+        EObject lv_expressions_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3330:2: ( ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* ) )
+            // InternalOXtype.g:3331:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* )
+            {
+            // InternalOXtype.g:3331:2: ( () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )* )
+            // InternalOXtype.g:3332:3: () ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )*
+            {
+            // InternalOXtype.g:3332:3: ()
+            // InternalOXtype.g:3333:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXExpressionInClosureAccess().getXBlockExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:3339:3: ( ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )? )*
+            loop60:
+            do {
+                int alt60=2;
+                int LA60_0 = input.LA(1);
+
+                if ( ((LA60_0>=RULE_STRING && LA60_0<=RULE_ID)||(LA60_0>=13 && LA60_0<=15)||LA60_0==20||(LA60_0>=24 && LA60_0<=25)||LA60_0==32||(LA60_0>=48 && LA60_0<=49)||LA60_0==53||LA60_0==60||LA60_0==63||LA60_0==65||(LA60_0>=69 && LA60_0<=83)||LA60_0==85) ) {
+                    alt60=1;
+                }
+
+
+                switch (alt60) {
+            	case 1 :
+            	    // InternalOXtype.g:3340:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_2= ';' )?
+            	    {
+            	    // InternalOXtype.g:3340:4: ( (lv_expressions_1_0= ruleXExpressionOrVarDeclaration ) )
+            	    // InternalOXtype.g:3341:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration )
+            	    {
+            	    // InternalOXtype.g:3341:5: (lv_expressions_1_0= ruleXExpressionOrVarDeclaration )
+            	    // InternalOXtype.g:3342:6: lv_expressions_1_0= ruleXExpressionOrVarDeclaration
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXExpressionInClosureAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_1_0_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_50);
+            	    lv_expressions_1_0=ruleXExpressionOrVarDeclaration();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXExpressionInClosureRule());
+            	      						}
+            	      						add(
+            	      							current,
+            	      							"expressions",
+            	      							lv_expressions_1_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:3359:4: (otherlv_2= ';' )?
+            	    int alt59=2;
+            	    int LA59_0 = input.LA(1);
+
+            	    if ( (LA59_0==18) ) {
+            	        alt59=1;
+            	    }
+            	    switch (alt59) {
+            	        case 1 :
+            	            // InternalOXtype.g:3360:5: otherlv_2= ';'
+            	            {
+            	            otherlv_2=(Token)match(input,18,FOLLOW_51); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              					newLeafNode(otherlv_2, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+            	              				
+            	            }
+
+            	            }
+            	            break;
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop60;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXExpressionInClosure"
+
+
+    // $ANTLR start "entryRuleXShortClosure"
+    // InternalOXtype.g:3370:1: entryRuleXShortClosure returns [EObject current=null] : iv_ruleXShortClosure= ruleXShortClosure EOF ;
+    public final EObject entryRuleXShortClosure() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXShortClosure = null;
+
+
+        try {
+            // InternalOXtype.g:3370:54: (iv_ruleXShortClosure= ruleXShortClosure EOF )
+            // InternalOXtype.g:3371:2: iv_ruleXShortClosure= ruleXShortClosure EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXShortClosureRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXShortClosure=ruleXShortClosure();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXShortClosure; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXShortClosure"
+
+
+    // $ANTLR start "ruleXShortClosure"
+    // InternalOXtype.g:3377:1: ruleXShortClosure returns [EObject current=null] : ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXShortClosure() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_2=null;
+        Token lv_explicitSyntax_4_0=null;
+        EObject lv_declaredFormalParameters_1_0 = null;
+
+        EObject lv_declaredFormalParameters_3_0 = null;
+
+        EObject lv_expression_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3383:2: ( ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:3384:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:3384:2: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) ) )
+            // InternalOXtype.g:3385:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) ) ( (lv_expression_5_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:3385:3: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) ) )
+            // InternalOXtype.g:3386:4: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) )
+            {
+            // InternalOXtype.g:3411:4: ( () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) ) )
+            // InternalOXtype.g:3412:5: () ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_4_0= '|' ) )
+            {
+            // InternalOXtype.g:3412:5: ()
+            // InternalOXtype.g:3413:6: 
+            {
+            if ( state.backtracking==0 ) {
+
+              						current = forceCreateModelElement(
+              							grammarAccess.getXShortClosureAccess().getXClosureAction_0_0_0(),
+              							current);
+              					
+            }
+
+            }
+
+            // InternalOXtype.g:3419:5: ( ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )* )?
+            int alt62=2;
+            int LA62_0 = input.LA(1);
+
+            if ( (LA62_0==RULE_ID||LA62_0==20||LA62_0==45) ) {
+                alt62=1;
+            }
+            switch (alt62) {
+                case 1 :
+                    // InternalOXtype.g:3420:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) ) (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )*
+                    {
+                    // InternalOXtype.g:3420:6: ( (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter ) )
+                    // InternalOXtype.g:3421:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter )
+                    {
+                    // InternalOXtype.g:3421:7: (lv_declaredFormalParameters_1_0= ruleJvmFormalParameter )
+                    // InternalOXtype.g:3422:8: lv_declaredFormalParameters_1_0= ruleJvmFormalParameter
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      								newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_0_0());
+                      							
+                    }
+                    pushFollow(FOLLOW_47);
+                    lv_declaredFormalParameters_1_0=ruleJvmFormalParameter();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      								if (current==null) {
+                      									current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+                      								}
+                      								add(
+                      									current,
+                      									"declaredFormalParameters",
+                      									lv_declaredFormalParameters_1_0,
+                      									"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+                      								afterParserOrEnumRuleCall();
+                      							
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:3439:6: (otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) ) )*
+                    loop61:
+                    do {
+                        int alt61=2;
+                        int LA61_0 = input.LA(1);
+
+                        if ( (LA61_0==21) ) {
+                            alt61=1;
+                        }
+
+
+                        switch (alt61) {
+                    	case 1 :
+                    	    // InternalOXtype.g:3440:7: otherlv_2= ',' ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) )
+                    	    {
+                    	    otherlv_2=(Token)match(input,21,FOLLOW_26); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newLeafNode(otherlv_2, grammarAccess.getXShortClosureAccess().getCommaKeyword_0_0_1_1_0());
+                    	      						
+                    	    }
+                    	    // InternalOXtype.g:3444:7: ( (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter ) )
+                    	    // InternalOXtype.g:3445:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter )
+                    	    {
+                    	    // InternalOXtype.g:3445:8: (lv_declaredFormalParameters_3_0= ruleJvmFormalParameter )
+                    	    // InternalOXtype.g:3446:9: lv_declaredFormalParameters_3_0= ruleJvmFormalParameter
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      									newCompositeNode(grammarAccess.getXShortClosureAccess().getDeclaredFormalParametersJvmFormalParameterParserRuleCall_0_0_1_1_1_0());
+                    	      								
+                    	    }
+                    	    pushFollow(FOLLOW_47);
+                    	    lv_declaredFormalParameters_3_0=ruleJvmFormalParameter();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      									if (current==null) {
+                    	      										current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+                    	      									}
+                    	      									add(
+                    	      										current,
+                    	      										"declaredFormalParameters",
+                    	      										lv_declaredFormalParameters_3_0,
+                    	      										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+                    	      									afterParserOrEnumRuleCall();
+                    	      								
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop61;
+                        }
+                    } while (true);
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:3465:5: ( (lv_explicitSyntax_4_0= '|' ) )
+            // InternalOXtype.g:3466:6: (lv_explicitSyntax_4_0= '|' )
+            {
+            // InternalOXtype.g:3466:6: (lv_explicitSyntax_4_0= '|' )
+            // InternalOXtype.g:3467:7: lv_explicitSyntax_4_0= '|'
+            {
+            lv_explicitSyntax_4_0=(Token)match(input,62,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              							newLeafNode(lv_explicitSyntax_4_0, grammarAccess.getXShortClosureAccess().getExplicitSyntaxVerticalLineKeyword_0_0_2_0());
+              						
+            }
+            if ( state.backtracking==0 ) {
+
+              							if (current==null) {
+              								current = createModelElement(grammarAccess.getXShortClosureRule());
+              							}
+              							setWithLastConsumed(current, "explicitSyntax", true, "|");
+              						
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:3481:3: ( (lv_expression_5_0= ruleXExpression ) )
+            // InternalOXtype.g:3482:4: (lv_expression_5_0= ruleXExpression )
+            {
+            // InternalOXtype.g:3482:4: (lv_expression_5_0= ruleXExpression )
+            // InternalOXtype.g:3483:5: lv_expression_5_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXShortClosureAccess().getExpressionXExpressionParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_expression_5_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXShortClosureRule());
+              					}
+              					set(
+              						current,
+              						"expression",
+              						lv_expression_5_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXShortClosure"
+
+
+    // $ANTLR start "entryRuleXParenthesizedExpression"
+    // InternalOXtype.g:3504:1: entryRuleXParenthesizedExpression returns [EObject current=null] : iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF ;
+    public final EObject entryRuleXParenthesizedExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXParenthesizedExpression = null;
+
+
+        try {
+            // InternalOXtype.g:3504:65: (iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF )
+            // InternalOXtype.g:3505:2: iv_ruleXParenthesizedExpression= ruleXParenthesizedExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXParenthesizedExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXParenthesizedExpression=ruleXParenthesizedExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXParenthesizedExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXParenthesizedExpression"
+
+
+    // $ANTLR start "ruleXParenthesizedExpression"
+    // InternalOXtype.g:3511:1: ruleXParenthesizedExpression returns [EObject current=null] : (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) ;
+    public final EObject ruleXParenthesizedExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        Token otherlv_2=null;
+        EObject this_XExpression_1 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3517:2: ( (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' ) )
+            // InternalOXtype.g:3518:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' )
+            {
+            // InternalOXtype.g:3518:2: (otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')' )
+            // InternalOXtype.g:3519:3: otherlv_0= '(' this_XExpression_1= ruleXExpression otherlv_2= ')'
+            {
+            otherlv_0=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_0, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+              		
+            }
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getXParenthesizedExpressionAccess().getXExpressionParserRuleCall_1());
+              		
+            }
+            pushFollow(FOLLOW_11);
+            this_XExpression_1=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current = this_XExpression_1;
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            otherlv_2=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXParenthesizedExpressionAccess().getRightParenthesisKeyword_2());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXParenthesizedExpression"
+
+
+    // $ANTLR start "entryRuleXIfExpression"
+    // InternalOXtype.g:3539:1: entryRuleXIfExpression returns [EObject current=null] : iv_ruleXIfExpression= ruleXIfExpression EOF ;
+    public final EObject entryRuleXIfExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXIfExpression = null;
+
+
+        try {
+            // InternalOXtype.g:3539:54: (iv_ruleXIfExpression= ruleXIfExpression EOF )
+            // InternalOXtype.g:3540:2: iv_ruleXIfExpression= ruleXIfExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXIfExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXIfExpression=ruleXIfExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXIfExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXIfExpression"
+
+
+    // $ANTLR start "ruleXIfExpression"
+    // InternalOXtype.g:3546:1: ruleXIfExpression returns [EObject current=null] : ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) ;
+    public final EObject ruleXIfExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_if_3_0 = null;
+
+        EObject lv_then_5_0 = null;
+
+        EObject lv_else_7_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3552:2: ( ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? ) )
+            // InternalOXtype.g:3553:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? )
+            {
+            // InternalOXtype.g:3553:2: ( () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )? )
+            // InternalOXtype.g:3554:3: () otherlv_1= 'if' otherlv_2= '(' ( (lv_if_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_then_5_0= ruleXExpression ) ) ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )?
+            {
+            // InternalOXtype.g:3554:3: ()
+            // InternalOXtype.g:3555:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXIfExpressionAccess().getXIfExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,63,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXIfExpressionAccess().getIfKeyword_1());
+              		
+            }
+            otherlv_2=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXIfExpressionAccess().getLeftParenthesisKeyword_2());
+              		
+            }
+            // InternalOXtype.g:3569:3: ( (lv_if_3_0= ruleXExpression ) )
+            // InternalOXtype.g:3570:4: (lv_if_3_0= ruleXExpression )
+            {
+            // InternalOXtype.g:3570:4: (lv_if_3_0= ruleXExpression )
+            // InternalOXtype.g:3571:5: lv_if_3_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXIfExpressionAccess().getIfXExpressionParserRuleCall_3_0());
+              				
+            }
+            pushFollow(FOLLOW_11);
+            lv_if_3_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+              					}
+              					set(
+              						current,
+              						"if",
+              						lv_if_3_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_4=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_4, grammarAccess.getXIfExpressionAccess().getRightParenthesisKeyword_4());
+              		
+            }
+            // InternalOXtype.g:3592:3: ( (lv_then_5_0= ruleXExpression ) )
+            // InternalOXtype.g:3593:4: (lv_then_5_0= ruleXExpression )
+            {
+            // InternalOXtype.g:3593:4: (lv_then_5_0= ruleXExpression )
+            // InternalOXtype.g:3594:5: lv_then_5_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXIfExpressionAccess().getThenXExpressionParserRuleCall_5_0());
+              				
+            }
+            pushFollow(FOLLOW_53);
+            lv_then_5_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+              					}
+              					set(
+              						current,
+              						"then",
+              						lv_then_5_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:3611:3: ( ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) ) )?
+            int alt63=2;
+            int LA63_0 = input.LA(1);
+
+            if ( (LA63_0==64) ) {
+                int LA63_1 = input.LA(2);
+
+                if ( (synpred31_InternalOXtype()) ) {
+                    alt63=1;
+                }
+            }
+            switch (alt63) {
+                case 1 :
+                    // InternalOXtype.g:3612:4: ( ( 'else' )=>otherlv_6= 'else' ) ( (lv_else_7_0= ruleXExpression ) )
+                    {
+                    // InternalOXtype.g:3612:4: ( ( 'else' )=>otherlv_6= 'else' )
+                    // InternalOXtype.g:3613:5: ( 'else' )=>otherlv_6= 'else'
+                    {
+                    otherlv_6=(Token)match(input,64,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_6, grammarAccess.getXIfExpressionAccess().getElseKeyword_6_0());
+                      				
+                    }
+
+                    }
+
+                    // InternalOXtype.g:3619:4: ( (lv_else_7_0= ruleXExpression ) )
+                    // InternalOXtype.g:3620:5: (lv_else_7_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3620:5: (lv_else_7_0= ruleXExpression )
+                    // InternalOXtype.g:3621:6: lv_else_7_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXIfExpressionAccess().getElseXExpressionParserRuleCall_6_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_else_7_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXIfExpressionRule());
+                      						}
+                      						set(
+                      							current,
+                      							"else",
+                      							lv_else_7_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXIfExpression"
+
+
+    // $ANTLR start "entryRuleXSwitchExpression"
+    // InternalOXtype.g:3643:1: entryRuleXSwitchExpression returns [EObject current=null] : iv_ruleXSwitchExpression= ruleXSwitchExpression EOF ;
+    public final EObject entryRuleXSwitchExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXSwitchExpression = null;
+
+
+        try {
+            // InternalOXtype.g:3643:58: (iv_ruleXSwitchExpression= ruleXSwitchExpression EOF )
+            // InternalOXtype.g:3644:2: iv_ruleXSwitchExpression= ruleXSwitchExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXSwitchExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXSwitchExpression=ruleXSwitchExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXSwitchExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXSwitchExpression"
+
+
+    // $ANTLR start "ruleXSwitchExpression"
+    // InternalOXtype.g:3650:1: ruleXSwitchExpression returns [EObject current=null] : ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) ;
+    public final EObject ruleXSwitchExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        Token otherlv_8=null;
+        Token otherlv_10=null;
+        Token otherlv_12=null;
+        Token otherlv_13=null;
+        Token otherlv_15=null;
+        EObject lv_declaredParam_3_0 = null;
+
+        EObject lv_switch_5_0 = null;
+
+        EObject lv_declaredParam_7_0 = null;
+
+        EObject lv_switch_9_0 = null;
+
+        EObject lv_cases_11_0 = null;
+
+        EObject lv_default_14_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3656:2: ( ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' ) )
+            // InternalOXtype.g:3657:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' )
+            {
+            // InternalOXtype.g:3657:2: ( () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}' )
+            // InternalOXtype.g:3658:3: () otherlv_1= 'switch' ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) ) otherlv_10= '{' ( (lv_cases_11_0= ruleXCasePart ) )* (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )? otherlv_15= '}'
+            {
+            // InternalOXtype.g:3658:3: ()
+            // InternalOXtype.g:3659:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXSwitchExpressionAccess().getXSwitchExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,65,FOLLOW_54); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXSwitchExpressionAccess().getSwitchKeyword_1());
+              		
+            }
+            // InternalOXtype.g:3669:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )
+            int alt65=2;
+            alt65 = dfa65.predict(input);
+            switch (alt65) {
+                case 1 :
+                    // InternalOXtype.g:3670:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' )
+                    {
+                    // InternalOXtype.g:3670:4: ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' )
+                    // InternalOXtype.g:3671:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')'
+                    {
+                    // InternalOXtype.g:3671:5: ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) )
+                    // InternalOXtype.g:3672:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+                    {
+                    // InternalOXtype.g:3682:6: (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+                    // InternalOXtype.g:3683:7: otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':'
+                    {
+                    otherlv_2=(Token)match(input,20,FOLLOW_26); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							newLeafNode(otherlv_2, grammarAccess.getXSwitchExpressionAccess().getLeftParenthesisKeyword_2_0_0_0_0());
+                      						
+                    }
+                    // InternalOXtype.g:3687:7: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) )
+                    // InternalOXtype.g:3688:8: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+                    {
+                    // InternalOXtype.g:3688:8: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+                    // InternalOXtype.g:3689:9: lv_declaredParam_3_0= ruleJvmFormalParameter
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      									newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_0_0_0_1_0());
+                      								
+                    }
+                    pushFollow(FOLLOW_55);
+                    lv_declaredParam_3_0=ruleJvmFormalParameter();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      									if (current==null) {
+                      										current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+                      									}
+                      									set(
+                      										current,
+                      										"declaredParam",
+                      										lv_declaredParam_3_0,
+                      										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+                      									afterParserOrEnumRuleCall();
+                      								
+                    }
+
+                    }
+
+
+                    }
+
+                    otherlv_4=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							newLeafNode(otherlv_4, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_0_0_0_2());
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:3712:5: ( (lv_switch_5_0= ruleXExpression ) )
+                    // InternalOXtype.g:3713:6: (lv_switch_5_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3713:6: (lv_switch_5_0= ruleXExpression )
+                    // InternalOXtype.g:3714:7: lv_switch_5_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_0_1_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_11);
+                    lv_switch_5_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+                      							}
+                      							set(
+                      								current,
+                      								"switch",
+                      								lv_switch_5_0,
+                      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    otherlv_6=(Token)match(input,22,FOLLOW_43); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_6, grammarAccess.getXSwitchExpressionAccess().getRightParenthesisKeyword_2_0_2());
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3737:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) )
+                    {
+                    // InternalOXtype.g:3737:4: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) )
+                    // InternalOXtype.g:3738:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) )
+                    {
+                    // InternalOXtype.g:3738:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?
+                    int alt64=2;
+                    alt64 = dfa64.predict(input);
+                    switch (alt64) {
+                        case 1 :
+                            // InternalOXtype.g:3739:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' )
+                            {
+                            // InternalOXtype.g:3748:6: ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' )
+                            // InternalOXtype.g:3749:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':'
+                            {
+                            // InternalOXtype.g:3749:7: ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) )
+                            // InternalOXtype.g:3750:8: (lv_declaredParam_7_0= ruleJvmFormalParameter )
+                            {
+                            // InternalOXtype.g:3750:8: (lv_declaredParam_7_0= ruleJvmFormalParameter )
+                            // InternalOXtype.g:3751:9: lv_declaredParam_7_0= ruleJvmFormalParameter
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              									newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_2_1_0_0_0_0());
+                              								
+                            }
+                            pushFollow(FOLLOW_55);
+                            lv_declaredParam_7_0=ruleJvmFormalParameter();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              									if (current==null) {
+                              										current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+                              									}
+                              									set(
+                              										current,
+                              										"declaredParam",
+                              										lv_declaredParam_7_0,
+                              										"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+                              									afterParserOrEnumRuleCall();
+                              								
+                            }
+
+                            }
+
+
+                            }
+
+                            otherlv_8=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							newLeafNode(otherlv_8, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_2_1_0_0_1());
+                              						
+                            }
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+                    // InternalOXtype.g:3774:5: ( (lv_switch_9_0= ruleXExpression ) )
+                    // InternalOXtype.g:3775:6: (lv_switch_9_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3775:6: (lv_switch_9_0= ruleXExpression )
+                    // InternalOXtype.g:3776:7: lv_switch_9_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getSwitchXExpressionParserRuleCall_2_1_1_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_43);
+                    lv_switch_9_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+                      							}
+                      							set(
+                      								current,
+                      								"switch",
+                      								lv_switch_9_0,
+                      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_10=(Token)match(input,60,FOLLOW_56); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_10, grammarAccess.getXSwitchExpressionAccess().getLeftCurlyBracketKeyword_3());
+              		
+            }
+            // InternalOXtype.g:3799:3: ( (lv_cases_11_0= ruleXCasePart ) )*
+            loop66:
+            do {
+                int alt66=2;
+                int LA66_0 = input.LA(1);
+
+                if ( (LA66_0==RULE_ID||(LA66_0>=20 && LA66_0<=21)||LA66_0==45||LA66_0==66||LA66_0==68) ) {
+                    alt66=1;
+                }
+
+
+                switch (alt66) {
+            	case 1 :
+            	    // InternalOXtype.g:3800:4: (lv_cases_11_0= ruleXCasePart )
+            	    {
+            	    // InternalOXtype.g:3800:4: (lv_cases_11_0= ruleXCasePart )
+            	    // InternalOXtype.g:3801:5: lv_cases_11_0= ruleXCasePart
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      					newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getCasesXCasePartParserRuleCall_4_0());
+            	      				
+            	    }
+            	    pushFollow(FOLLOW_56);
+            	    lv_cases_11_0=ruleXCasePart();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      					if (current==null) {
+            	      						current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+            	      					}
+            	      					add(
+            	      						current,
+            	      						"cases",
+            	      						lv_cases_11_0,
+            	      						"org.eclipse.xtext.xbase.Xbase.XCasePart");
+            	      					afterParserOrEnumRuleCall();
+            	      				
+            	    }
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop66;
+                }
+            } while (true);
+
+            // InternalOXtype.g:3818:3: (otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) ) )?
+            int alt67=2;
+            int LA67_0 = input.LA(1);
+
+            if ( (LA67_0==67) ) {
+                alt67=1;
+            }
+            switch (alt67) {
+                case 1 :
+                    // InternalOXtype.g:3819:4: otherlv_12= 'default' otherlv_13= ':' ( (lv_default_14_0= ruleXExpression ) )
+                    {
+                    otherlv_12=(Token)match(input,67,FOLLOW_55); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_12, grammarAccess.getXSwitchExpressionAccess().getDefaultKeyword_5_0());
+                      			
+                    }
+                    otherlv_13=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_13, grammarAccess.getXSwitchExpressionAccess().getColonKeyword_5_1());
+                      			
+                    }
+                    // InternalOXtype.g:3827:4: ( (lv_default_14_0= ruleXExpression ) )
+                    // InternalOXtype.g:3828:5: (lv_default_14_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3828:5: (lv_default_14_0= ruleXExpression )
+                    // InternalOXtype.g:3829:6: lv_default_14_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXSwitchExpressionAccess().getDefaultXExpressionParserRuleCall_5_2_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_57);
+                    lv_default_14_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXSwitchExpressionRule());
+                      						}
+                      						set(
+                      							current,
+                      							"default",
+                      							lv_default_14_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_15=(Token)match(input,61,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_15, grammarAccess.getXSwitchExpressionAccess().getRightCurlyBracketKeyword_6());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXSwitchExpression"
+
+
+    // $ANTLR start "entryRuleXCasePart"
+    // InternalOXtype.g:3855:1: entryRuleXCasePart returns [EObject current=null] : iv_ruleXCasePart= ruleXCasePart EOF ;
+    public final EObject entryRuleXCasePart() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXCasePart = null;
+
+
+        try {
+            // InternalOXtype.g:3855:50: (iv_ruleXCasePart= ruleXCasePart EOF )
+            // InternalOXtype.g:3856:2: iv_ruleXCasePart= ruleXCasePart EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXCasePartRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXCasePart=ruleXCasePart();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXCasePart; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXCasePart"
+
+
+    // $ANTLR start "ruleXCasePart"
+    // InternalOXtype.g:3862:1: ruleXCasePart returns [EObject current=null] : ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) ;
+    public final EObject ruleXCasePart() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token lv_fallThrough_6_0=null;
+        EObject lv_typeGuard_1_0 = null;
+
+        EObject lv_case_3_0 = null;
+
+        EObject lv_then_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3868:2: ( ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) ) )
+            // InternalOXtype.g:3869:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) )
+            {
+            // InternalOXtype.g:3869:2: ( () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) ) )
+            // InternalOXtype.g:3870:3: () ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )? (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )? ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) )
+            {
+            // InternalOXtype.g:3870:3: ()
+            // InternalOXtype.g:3871:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXCasePartAccess().getXCasePartAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:3877:3: ( (lv_typeGuard_1_0= ruleJvmTypeReference ) )?
+            int alt68=2;
+            int LA68_0 = input.LA(1);
+
+            if ( (LA68_0==RULE_ID||LA68_0==20||LA68_0==45) ) {
+                alt68=1;
+            }
+            switch (alt68) {
+                case 1 :
+                    // InternalOXtype.g:3878:4: (lv_typeGuard_1_0= ruleJvmTypeReference )
+                    {
+                    // InternalOXtype.g:3878:4: (lv_typeGuard_1_0= ruleJvmTypeReference )
+                    // InternalOXtype.g:3879:5: lv_typeGuard_1_0= ruleJvmTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					newCompositeNode(grammarAccess.getXCasePartAccess().getTypeGuardJvmTypeReferenceParserRuleCall_1_0());
+                      				
+                    }
+                    pushFollow(FOLLOW_58);
+                    lv_typeGuard_1_0=ruleJvmTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					if (current==null) {
+                      						current = createModelElementForParent(grammarAccess.getXCasePartRule());
+                      					}
+                      					set(
+                      						current,
+                      						"typeGuard",
+                      						lv_typeGuard_1_0,
+                      						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+                      					afterParserOrEnumRuleCall();
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:3896:3: (otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) ) )?
+            int alt69=2;
+            int LA69_0 = input.LA(1);
+
+            if ( (LA69_0==68) ) {
+                alt69=1;
+            }
+            switch (alt69) {
+                case 1 :
+                    // InternalOXtype.g:3897:4: otherlv_2= 'case' ( (lv_case_3_0= ruleXExpression ) )
+                    {
+                    otherlv_2=(Token)match(input,68,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_2, grammarAccess.getXCasePartAccess().getCaseKeyword_2_0());
+                      			
+                    }
+                    // InternalOXtype.g:3901:4: ( (lv_case_3_0= ruleXExpression ) )
+                    // InternalOXtype.g:3902:5: (lv_case_3_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3902:5: (lv_case_3_0= ruleXExpression )
+                    // InternalOXtype.g:3903:6: lv_case_3_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXCasePartAccess().getCaseXExpressionParserRuleCall_2_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_59);
+                    lv_case_3_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXCasePartRule());
+                      						}
+                      						set(
+                      							current,
+                      							"case",
+                      							lv_case_3_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:3921:3: ( (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) ) | ( (lv_fallThrough_6_0= ',' ) ) )
+            int alt70=2;
+            int LA70_0 = input.LA(1);
+
+            if ( (LA70_0==66) ) {
+                alt70=1;
+            }
+            else if ( (LA70_0==21) ) {
+                alt70=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 70, 0, input);
+
+                throw nvae;
+            }
+            switch (alt70) {
+                case 1 :
+                    // InternalOXtype.g:3922:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) )
+                    {
+                    // InternalOXtype.g:3922:4: (otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) ) )
+                    // InternalOXtype.g:3923:5: otherlv_4= ':' ( (lv_then_5_0= ruleXExpression ) )
+                    {
+                    otherlv_4=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_4, grammarAccess.getXCasePartAccess().getColonKeyword_3_0_0());
+                      				
+                    }
+                    // InternalOXtype.g:3927:5: ( (lv_then_5_0= ruleXExpression ) )
+                    // InternalOXtype.g:3928:6: (lv_then_5_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:3928:6: (lv_then_5_0= ruleXExpression )
+                    // InternalOXtype.g:3929:7: lv_then_5_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXCasePartAccess().getThenXExpressionParserRuleCall_3_0_1_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_then_5_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getXCasePartRule());
+                      							}
+                      							set(
+                      								current,
+                      								"then",
+                      								lv_then_5_0,
+                      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:3948:4: ( (lv_fallThrough_6_0= ',' ) )
+                    {
+                    // InternalOXtype.g:3948:4: ( (lv_fallThrough_6_0= ',' ) )
+                    // InternalOXtype.g:3949:5: (lv_fallThrough_6_0= ',' )
+                    {
+                    // InternalOXtype.g:3949:5: (lv_fallThrough_6_0= ',' )
+                    // InternalOXtype.g:3950:6: lv_fallThrough_6_0= ','
+                    {
+                    lv_fallThrough_6_0=(Token)match(input,21,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(lv_fallThrough_6_0, grammarAccess.getXCasePartAccess().getFallThroughCommaKeyword_3_1_0());
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXCasePartRule());
+                      						}
+                      						setWithLastConsumed(current, "fallThrough", true, ",");
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXCasePart"
+
+
+    // $ANTLR start "entryRuleXForLoopExpression"
+    // InternalOXtype.g:3967:1: entryRuleXForLoopExpression returns [EObject current=null] : iv_ruleXForLoopExpression= ruleXForLoopExpression EOF ;
+    public final EObject entryRuleXForLoopExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXForLoopExpression = null;
+
+
+        try {
+            // InternalOXtype.g:3967:59: (iv_ruleXForLoopExpression= ruleXForLoopExpression EOF )
+            // InternalOXtype.g:3968:2: iv_ruleXForLoopExpression= ruleXForLoopExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXForLoopExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXForLoopExpression=ruleXForLoopExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXForLoopExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXForLoopExpression"
+
+
+    // $ANTLR start "ruleXForLoopExpression"
+    // InternalOXtype.g:3974:1: ruleXForLoopExpression returns [EObject current=null] : ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXForLoopExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_declaredParam_3_0 = null;
+
+        EObject lv_forExpression_5_0 = null;
+
+        EObject lv_eachExpression_7_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:3980:2: ( ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:3981:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:3981:2: ( ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) ) )
+            // InternalOXtype.g:3982:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_forExpression_5_0= ruleXExpression ) ) otherlv_6= ')' ( (lv_eachExpression_7_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:3982:3: ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) )
+            // InternalOXtype.g:3983:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+            {
+            // InternalOXtype.g:3996:4: ( () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' )
+            // InternalOXtype.g:3997:5: () otherlv_1= 'for' otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':'
+            {
+            // InternalOXtype.g:3997:5: ()
+            // InternalOXtype.g:3998:6: 
+            {
+            if ( state.backtracking==0 ) {
+
+              						current = forceCreateModelElement(
+              							grammarAccess.getXForLoopExpressionAccess().getXForLoopExpressionAction_0_0_0(),
+              							current);
+              					
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,69,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_1, grammarAccess.getXForLoopExpressionAccess().getForKeyword_0_0_1());
+              				
+            }
+            otherlv_2=(Token)match(input,20,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_2, grammarAccess.getXForLoopExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+              				
+            }
+            // InternalOXtype.g:4012:5: ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) )
+            // InternalOXtype.g:4013:6: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+            {
+            // InternalOXtype.g:4013:6: (lv_declaredParam_3_0= ruleJvmFormalParameter )
+            // InternalOXtype.g:4014:7: lv_declaredParam_3_0= ruleJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+
+              							newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getDeclaredParamJvmFormalParameterParserRuleCall_0_0_3_0());
+              						
+            }
+            pushFollow(FOLLOW_55);
+            lv_declaredParam_3_0=ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              							if (current==null) {
+              								current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+              							}
+              							set(
+              								current,
+              								"declaredParam",
+              								lv_declaredParam_3_0,
+              								"org.eclipse.xtext.xbase.Xbase.JvmFormalParameter");
+              							afterParserOrEnumRuleCall();
+              						
+            }
+
+            }
+
+
+            }
+
+            otherlv_4=(Token)match(input,66,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_4, grammarAccess.getXForLoopExpressionAccess().getColonKeyword_0_0_4());
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:4037:3: ( (lv_forExpression_5_0= ruleXExpression ) )
+            // InternalOXtype.g:4038:4: (lv_forExpression_5_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4038:4: (lv_forExpression_5_0= ruleXExpression )
+            // InternalOXtype.g:4039:5: lv_forExpression_5_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getForExpressionXExpressionParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_11);
+            lv_forExpression_5_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+              					}
+              					set(
+              						current,
+              						"forExpression",
+              						lv_forExpression_5_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_6=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_6, grammarAccess.getXForLoopExpressionAccess().getRightParenthesisKeyword_2());
+              		
+            }
+            // InternalOXtype.g:4060:3: ( (lv_eachExpression_7_0= ruleXExpression ) )
+            // InternalOXtype.g:4061:4: (lv_eachExpression_7_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4061:4: (lv_eachExpression_7_0= ruleXExpression )
+            // InternalOXtype.g:4062:5: lv_eachExpression_7_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_3_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_eachExpression_7_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXForLoopExpressionRule());
+              					}
+              					set(
+              						current,
+              						"eachExpression",
+              						lv_eachExpression_7_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXForLoopExpression"
+
+
+    // $ANTLR start "entryRuleXBasicForLoopExpression"
+    // InternalOXtype.g:4083:1: entryRuleXBasicForLoopExpression returns [EObject current=null] : iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF ;
+    public final EObject entryRuleXBasicForLoopExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXBasicForLoopExpression = null;
+
+
+        try {
+            // InternalOXtype.g:4083:64: (iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF )
+            // InternalOXtype.g:4084:2: iv_ruleXBasicForLoopExpression= ruleXBasicForLoopExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXBasicForLoopExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXBasicForLoopExpression=ruleXBasicForLoopExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXBasicForLoopExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXBasicForLoopExpression"
+
+
+    // $ANTLR start "ruleXBasicForLoopExpression"
+    // InternalOXtype.g:4090:1: ruleXBasicForLoopExpression returns [EObject current=null] : ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXBasicForLoopExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        Token otherlv_8=null;
+        Token otherlv_10=null;
+        Token otherlv_12=null;
+        EObject lv_initExpressions_3_0 = null;
+
+        EObject lv_initExpressions_5_0 = null;
+
+        EObject lv_expression_7_0 = null;
+
+        EObject lv_updateExpressions_9_0 = null;
+
+        EObject lv_updateExpressions_11_0 = null;
+
+        EObject lv_eachExpression_13_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4096:2: ( ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:4097:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:4097:2: ( () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) ) )
+            // InternalOXtype.g:4098:3: () otherlv_1= 'for' otherlv_2= '(' ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )? otherlv_6= ';' ( (lv_expression_7_0= ruleXExpression ) )? otherlv_8= ';' ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )? otherlv_12= ')' ( (lv_eachExpression_13_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:4098:3: ()
+            // InternalOXtype.g:4099:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXBasicForLoopExpressionAccess().getXBasicForLoopExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,69,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXBasicForLoopExpressionAccess().getForKeyword_1());
+              		
+            }
+            otherlv_2=(Token)match(input,20,FOLLOW_60); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXBasicForLoopExpressionAccess().getLeftParenthesisKeyword_2());
+              		
+            }
+            // InternalOXtype.g:4113:3: ( ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )* )?
+            int alt72=2;
+            int LA72_0 = input.LA(1);
+
+            if ( ((LA72_0>=RULE_STRING && LA72_0<=RULE_ID)||(LA72_0>=13 && LA72_0<=15)||LA72_0==20||(LA72_0>=24 && LA72_0<=25)||LA72_0==32||(LA72_0>=48 && LA72_0<=49)||LA72_0==53||LA72_0==60||LA72_0==63||LA72_0==65||(LA72_0>=69 && LA72_0<=83)||LA72_0==85) ) {
+                alt72=1;
+            }
+            switch (alt72) {
+                case 1 :
+                    // InternalOXtype.g:4114:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )*
+                    {
+                    // InternalOXtype.g:4114:4: ( (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration ) )
+                    // InternalOXtype.g:4115:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration )
+                    {
+                    // InternalOXtype.g:4115:5: (lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration )
+                    // InternalOXtype.g:4116:6: lv_initExpressions_3_0= ruleXExpressionOrVarDeclaration
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_0_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_61);
+                    lv_initExpressions_3_0=ruleXExpressionOrVarDeclaration();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+                      						}
+                      						add(
+                      							current,
+                      							"initExpressions",
+                      							lv_initExpressions_3_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:4133:4: (otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) ) )*
+                    loop71:
+                    do {
+                        int alt71=2;
+                        int LA71_0 = input.LA(1);
+
+                        if ( (LA71_0==21) ) {
+                            alt71=1;
+                        }
+
+
+                        switch (alt71) {
+                    	case 1 :
+                    	    // InternalOXtype.g:4134:5: otherlv_4= ',' ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) )
+                    	    {
+                    	    otherlv_4=(Token)match(input,21,FOLLOW_62); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_4, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_3_1_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:4138:5: ( (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration ) )
+                    	    // InternalOXtype.g:4139:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration )
+                    	    {
+                    	    // InternalOXtype.g:4139:6: (lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration )
+                    	    // InternalOXtype.g:4140:7: lv_initExpressions_5_0= ruleXExpressionOrVarDeclaration
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getInitExpressionsXExpressionOrVarDeclarationParserRuleCall_3_1_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_61);
+                    	    lv_initExpressions_5_0=ruleXExpressionOrVarDeclaration();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"initExpressions",
+                    	      								lv_initExpressions_5_0,
+                    	      								"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop71;
+                        }
+                    } while (true);
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_6=(Token)match(input,18,FOLLOW_63); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_6, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_4());
+              		
+            }
+            // InternalOXtype.g:4163:3: ( (lv_expression_7_0= ruleXExpression ) )?
+            int alt73=2;
+            int LA73_0 = input.LA(1);
+
+            if ( ((LA73_0>=RULE_STRING && LA73_0<=RULE_ID)||(LA73_0>=13 && LA73_0<=15)||LA73_0==20||(LA73_0>=24 && LA73_0<=25)||LA73_0==32||(LA73_0>=48 && LA73_0<=49)||LA73_0==53||LA73_0==60||LA73_0==63||LA73_0==65||(LA73_0>=69 && LA73_0<=71)||(LA73_0>=74 && LA73_0<=83)||LA73_0==85) ) {
+                alt73=1;
+            }
+            switch (alt73) {
+                case 1 :
+                    // InternalOXtype.g:4164:4: (lv_expression_7_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:4164:4: (lv_expression_7_0= ruleXExpression )
+                    // InternalOXtype.g:4165:5: lv_expression_7_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getExpressionXExpressionParserRuleCall_5_0());
+                      				
+                    }
+                    pushFollow(FOLLOW_64);
+                    lv_expression_7_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					if (current==null) {
+                      						current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+                      					}
+                      					set(
+                      						current,
+                      						"expression",
+                      						lv_expression_7_0,
+                      						"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      					afterParserOrEnumRuleCall();
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_8=(Token)match(input,18,FOLLOW_9); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_8, grammarAccess.getXBasicForLoopExpressionAccess().getSemicolonKeyword_6());
+              		
+            }
+            // InternalOXtype.g:4186:3: ( ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )* )?
+            int alt75=2;
+            int LA75_0 = input.LA(1);
+
+            if ( ((LA75_0>=RULE_STRING && LA75_0<=RULE_ID)||(LA75_0>=13 && LA75_0<=15)||LA75_0==20||(LA75_0>=24 && LA75_0<=25)||LA75_0==32||(LA75_0>=48 && LA75_0<=49)||LA75_0==53||LA75_0==60||LA75_0==63||LA75_0==65||(LA75_0>=69 && LA75_0<=71)||(LA75_0>=74 && LA75_0<=83)||LA75_0==85) ) {
+                alt75=1;
+            }
+            switch (alt75) {
+                case 1 :
+                    // InternalOXtype.g:4187:4: ( (lv_updateExpressions_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )*
+                    {
+                    // InternalOXtype.g:4187:4: ( (lv_updateExpressions_9_0= ruleXExpression ) )
+                    // InternalOXtype.g:4188:5: (lv_updateExpressions_9_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:4188:5: (lv_updateExpressions_9_0= ruleXExpression )
+                    // InternalOXtype.g:4189:6: lv_updateExpressions_9_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_0_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_10);
+                    lv_updateExpressions_9_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+                      						}
+                      						add(
+                      							current,
+                      							"updateExpressions",
+                      							lv_updateExpressions_9_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:4206:4: (otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) ) )*
+                    loop74:
+                    do {
+                        int alt74=2;
+                        int LA74_0 = input.LA(1);
+
+                        if ( (LA74_0==21) ) {
+                            alt74=1;
+                        }
+
+
+                        switch (alt74) {
+                    	case 1 :
+                    	    // InternalOXtype.g:4207:5: otherlv_10= ',' ( (lv_updateExpressions_11_0= ruleXExpression ) )
+                    	    {
+                    	    otherlv_10=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_10, grammarAccess.getXBasicForLoopExpressionAccess().getCommaKeyword_7_1_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:4211:5: ( (lv_updateExpressions_11_0= ruleXExpression ) )
+                    	    // InternalOXtype.g:4212:6: (lv_updateExpressions_11_0= ruleXExpression )
+                    	    {
+                    	    // InternalOXtype.g:4212:6: (lv_updateExpressions_11_0= ruleXExpression )
+                    	    // InternalOXtype.g:4213:7: lv_updateExpressions_11_0= ruleXExpression
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getUpdateExpressionsXExpressionParserRuleCall_7_1_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_10);
+                    	    lv_updateExpressions_11_0=ruleXExpression();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"updateExpressions",
+                    	      								lv_updateExpressions_11_0,
+                    	      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop74;
+                        }
+                    } while (true);
+
+
+                    }
+                    break;
+
+            }
+
+            otherlv_12=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_12, grammarAccess.getXBasicForLoopExpressionAccess().getRightParenthesisKeyword_8());
+              		
+            }
+            // InternalOXtype.g:4236:3: ( (lv_eachExpression_13_0= ruleXExpression ) )
+            // InternalOXtype.g:4237:4: (lv_eachExpression_13_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4237:4: (lv_eachExpression_13_0= ruleXExpression )
+            // InternalOXtype.g:4238:5: lv_eachExpression_13_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXBasicForLoopExpressionAccess().getEachExpressionXExpressionParserRuleCall_9_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_eachExpression_13_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXBasicForLoopExpressionRule());
+              					}
+              					set(
+              						current,
+              						"eachExpression",
+              						lv_eachExpression_13_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXBasicForLoopExpression"
+
+
+    // $ANTLR start "entryRuleXWhileExpression"
+    // InternalOXtype.g:4259:1: entryRuleXWhileExpression returns [EObject current=null] : iv_ruleXWhileExpression= ruleXWhileExpression EOF ;
+    public final EObject entryRuleXWhileExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXWhileExpression = null;
+
+
+        try {
+            // InternalOXtype.g:4259:57: (iv_ruleXWhileExpression= ruleXWhileExpression EOF )
+            // InternalOXtype.g:4260:2: iv_ruleXWhileExpression= ruleXWhileExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXWhileExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXWhileExpression=ruleXWhileExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXWhileExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXWhileExpression"
+
+
+    // $ANTLR start "ruleXWhileExpression"
+    // InternalOXtype.g:4266:1: ruleXWhileExpression returns [EObject current=null] : ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXWhileExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        EObject lv_predicate_3_0 = null;
+
+        EObject lv_body_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4272:2: ( ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:4273:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:4273:2: ( () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) ) )
+            // InternalOXtype.g:4274:3: () otherlv_1= 'while' otherlv_2= '(' ( (lv_predicate_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_body_5_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:4274:3: ()
+            // InternalOXtype.g:4275:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXWhileExpressionAccess().getXWhileExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,70,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXWhileExpressionAccess().getWhileKeyword_1());
+              		
+            }
+            otherlv_2=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXWhileExpressionAccess().getLeftParenthesisKeyword_2());
+              		
+            }
+            // InternalOXtype.g:4289:3: ( (lv_predicate_3_0= ruleXExpression ) )
+            // InternalOXtype.g:4290:4: (lv_predicate_3_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4290:4: (lv_predicate_3_0= ruleXExpression )
+            // InternalOXtype.g:4291:5: lv_predicate_3_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXWhileExpressionAccess().getPredicateXExpressionParserRuleCall_3_0());
+              				
+            }
+            pushFollow(FOLLOW_11);
+            lv_predicate_3_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+              					}
+              					set(
+              						current,
+              						"predicate",
+              						lv_predicate_3_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_4=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_4, grammarAccess.getXWhileExpressionAccess().getRightParenthesisKeyword_4());
+              		
+            }
+            // InternalOXtype.g:4312:3: ( (lv_body_5_0= ruleXExpression ) )
+            // InternalOXtype.g:4313:4: (lv_body_5_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4313:4: (lv_body_5_0= ruleXExpression )
+            // InternalOXtype.g:4314:5: lv_body_5_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXWhileExpressionAccess().getBodyXExpressionParserRuleCall_5_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_body_5_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXWhileExpressionRule());
+              					}
+              					set(
+              						current,
+              						"body",
+              						lv_body_5_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXWhileExpression"
+
+
+    // $ANTLR start "entryRuleXDoWhileExpression"
+    // InternalOXtype.g:4335:1: entryRuleXDoWhileExpression returns [EObject current=null] : iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF ;
+    public final EObject entryRuleXDoWhileExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXDoWhileExpression = null;
+
+
+        try {
+            // InternalOXtype.g:4335:59: (iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF )
+            // InternalOXtype.g:4336:2: iv_ruleXDoWhileExpression= ruleXDoWhileExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXDoWhileExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXDoWhileExpression=ruleXDoWhileExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXDoWhileExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXDoWhileExpression"
+
+
+    // $ANTLR start "ruleXDoWhileExpression"
+    // InternalOXtype.g:4342:1: ruleXDoWhileExpression returns [EObject current=null] : ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) ;
+    public final EObject ruleXDoWhileExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_body_2_0 = null;
+
+        EObject lv_predicate_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4348:2: ( ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' ) )
+            // InternalOXtype.g:4349:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' )
+            {
+            // InternalOXtype.g:4349:2: ( () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')' )
+            // InternalOXtype.g:4350:3: () otherlv_1= 'do' ( (lv_body_2_0= ruleXExpression ) ) otherlv_3= 'while' otherlv_4= '(' ( (lv_predicate_5_0= ruleXExpression ) ) otherlv_6= ')'
+            {
+            // InternalOXtype.g:4350:3: ()
+            // InternalOXtype.g:4351:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXDoWhileExpressionAccess().getXDoWhileExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,71,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXDoWhileExpressionAccess().getDoKeyword_1());
+              		
+            }
+            // InternalOXtype.g:4361:3: ( (lv_body_2_0= ruleXExpression ) )
+            // InternalOXtype.g:4362:4: (lv_body_2_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4362:4: (lv_body_2_0= ruleXExpression )
+            // InternalOXtype.g:4363:5: lv_body_2_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getBodyXExpressionParserRuleCall_2_0());
+              				
+            }
+            pushFollow(FOLLOW_65);
+            lv_body_2_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+              					}
+              					set(
+              						current,
+              						"body",
+              						lv_body_2_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_3=(Token)match(input,70,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_3, grammarAccess.getXDoWhileExpressionAccess().getWhileKeyword_3());
+              		
+            }
+            otherlv_4=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_4, grammarAccess.getXDoWhileExpressionAccess().getLeftParenthesisKeyword_4());
+              		
+            }
+            // InternalOXtype.g:4388:3: ( (lv_predicate_5_0= ruleXExpression ) )
+            // InternalOXtype.g:4389:4: (lv_predicate_5_0= ruleXExpression )
+            {
+            // InternalOXtype.g:4389:4: (lv_predicate_5_0= ruleXExpression )
+            // InternalOXtype.g:4390:5: lv_predicate_5_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXDoWhileExpressionAccess().getPredicateXExpressionParserRuleCall_5_0());
+              				
+            }
+            pushFollow(FOLLOW_11);
+            lv_predicate_5_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXDoWhileExpressionRule());
+              					}
+              					set(
+              						current,
+              						"predicate",
+              						lv_predicate_5_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_6=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_6, grammarAccess.getXDoWhileExpressionAccess().getRightParenthesisKeyword_6());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXDoWhileExpression"
+
+
+    // $ANTLR start "entryRuleXBlockExpression"
+    // InternalOXtype.g:4415:1: entryRuleXBlockExpression returns [EObject current=null] : iv_ruleXBlockExpression= ruleXBlockExpression EOF ;
+    public final EObject entryRuleXBlockExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXBlockExpression = null;
+
+
+        try {
+            // InternalOXtype.g:4415:57: (iv_ruleXBlockExpression= ruleXBlockExpression EOF )
+            // InternalOXtype.g:4416:2: iv_ruleXBlockExpression= ruleXBlockExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXBlockExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXBlockExpression=ruleXBlockExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXBlockExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXBlockExpression"
+
+
+    // $ANTLR start "ruleXBlockExpression"
+    // InternalOXtype.g:4422:1: ruleXBlockExpression returns [EObject current=null] : ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) ;
+    public final EObject ruleXBlockExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_4=null;
+        EObject lv_expressions_2_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4428:2: ( ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' ) )
+            // InternalOXtype.g:4429:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' )
+            {
+            // InternalOXtype.g:4429:2: ( () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}' )
+            // InternalOXtype.g:4430:3: () otherlv_1= '{' ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )* otherlv_4= '}'
+            {
+            // InternalOXtype.g:4430:3: ()
+            // InternalOXtype.g:4431:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXBlockExpressionAccess().getXBlockExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,60,FOLLOW_66); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXBlockExpressionAccess().getLeftCurlyBracketKeyword_1());
+              		
+            }
+            // InternalOXtype.g:4441:3: ( ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )? )*
+            loop77:
+            do {
+                int alt77=2;
+                int LA77_0 = input.LA(1);
+
+                if ( ((LA77_0>=RULE_STRING && LA77_0<=RULE_ID)||(LA77_0>=13 && LA77_0<=15)||LA77_0==20||(LA77_0>=24 && LA77_0<=25)||LA77_0==32||(LA77_0>=48 && LA77_0<=49)||LA77_0==53||LA77_0==60||LA77_0==63||LA77_0==65||(LA77_0>=69 && LA77_0<=83)||LA77_0==85) ) {
+                    alt77=1;
+                }
+
+
+                switch (alt77) {
+            	case 1 :
+            	    // InternalOXtype.g:4442:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) ) (otherlv_3= ';' )?
+            	    {
+            	    // InternalOXtype.g:4442:4: ( (lv_expressions_2_0= ruleXExpressionOrVarDeclaration ) )
+            	    // InternalOXtype.g:4443:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration )
+            	    {
+            	    // InternalOXtype.g:4443:5: (lv_expressions_2_0= ruleXExpressionOrVarDeclaration )
+            	    // InternalOXtype.g:4444:6: lv_expressions_2_0= ruleXExpressionOrVarDeclaration
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      						newCompositeNode(grammarAccess.getXBlockExpressionAccess().getExpressionsXExpressionOrVarDeclarationParserRuleCall_2_0_0());
+            	      					
+            	    }
+            	    pushFollow(FOLLOW_67);
+            	    lv_expressions_2_0=ruleXExpressionOrVarDeclaration();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      						if (current==null) {
+            	      							current = createModelElementForParent(grammarAccess.getXBlockExpressionRule());
+            	      						}
+            	      						add(
+            	      							current,
+            	      							"expressions",
+            	      							lv_expressions_2_0,
+            	      							"org.eclipse.xtext.xbase.Xbase.XExpressionOrVarDeclaration");
+            	      						afterParserOrEnumRuleCall();
+            	      					
+            	    }
+
+            	    }
+
+
+            	    }
+
+            	    // InternalOXtype.g:4461:4: (otherlv_3= ';' )?
+            	    int alt76=2;
+            	    int LA76_0 = input.LA(1);
+
+            	    if ( (LA76_0==18) ) {
+            	        alt76=1;
+            	    }
+            	    switch (alt76) {
+            	        case 1 :
+            	            // InternalOXtype.g:4462:5: otherlv_3= ';'
+            	            {
+            	            otherlv_3=(Token)match(input,18,FOLLOW_66); if (state.failed) return current;
+            	            if ( state.backtracking==0 ) {
+
+            	              					newLeafNode(otherlv_3, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+            	              				
+            	            }
+
+            	            }
+            	            break;
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop77;
+                }
+            } while (true);
+
+            otherlv_4=(Token)match(input,61,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_4, grammarAccess.getXBlockExpressionAccess().getRightCurlyBracketKeyword_3());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXBlockExpression"
+
+
+    // $ANTLR start "entryRuleXExpressionOrVarDeclaration"
+    // InternalOXtype.g:4476:1: entryRuleXExpressionOrVarDeclaration returns [EObject current=null] : iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF ;
+    public final EObject entryRuleXExpressionOrVarDeclaration() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXExpressionOrVarDeclaration = null;
+
+
+        try {
+            // InternalOXtype.g:4476:68: (iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF )
+            // InternalOXtype.g:4477:2: iv_ruleXExpressionOrVarDeclaration= ruleXExpressionOrVarDeclaration EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXExpressionOrVarDeclaration=ruleXExpressionOrVarDeclaration();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXExpressionOrVarDeclaration; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXExpressionOrVarDeclaration"
+
+
+    // $ANTLR start "ruleXExpressionOrVarDeclaration"
+    // InternalOXtype.g:4483:1: ruleXExpressionOrVarDeclaration returns [EObject current=null] : (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) ;
+    public final EObject ruleXExpressionOrVarDeclaration() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_XVariableDeclaration_0 = null;
+
+        EObject this_XExpression_1 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4489:2: ( (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression ) )
+            // InternalOXtype.g:4490:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression )
+            {
+            // InternalOXtype.g:4490:2: (this_XVariableDeclaration_0= ruleXVariableDeclaration | this_XExpression_1= ruleXExpression )
+            int alt78=2;
+            int LA78_0 = input.LA(1);
+
+            if ( ((LA78_0>=72 && LA78_0<=73)) ) {
+                alt78=1;
+            }
+            else if ( ((LA78_0>=RULE_STRING && LA78_0<=RULE_ID)||(LA78_0>=13 && LA78_0<=15)||LA78_0==20||(LA78_0>=24 && LA78_0<=25)||LA78_0==32||(LA78_0>=48 && LA78_0<=49)||LA78_0==53||LA78_0==60||LA78_0==63||LA78_0==65||(LA78_0>=69 && LA78_0<=71)||(LA78_0>=74 && LA78_0<=83)||LA78_0==85) ) {
+                alt78=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 78, 0, input);
+
+                throw nvae;
+            }
+            switch (alt78) {
+                case 1 :
+                    // InternalOXtype.g:4491:3: this_XVariableDeclaration_0= ruleXVariableDeclaration
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXVariableDeclarationParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XVariableDeclaration_0=ruleXVariableDeclaration();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XVariableDeclaration_0;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:4500:3: this_XExpression_1= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getXExpressionOrVarDeclarationAccess().getXExpressionParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XExpression_1=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XExpression_1;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXExpressionOrVarDeclaration"
+
+
+    // $ANTLR start "entryRuleXVariableDeclaration"
+    // InternalOXtype.g:4512:1: entryRuleXVariableDeclaration returns [EObject current=null] : iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF ;
+    public final EObject entryRuleXVariableDeclaration() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXVariableDeclaration = null;
+
+
+        try {
+            // InternalOXtype.g:4512:61: (iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF )
+            // InternalOXtype.g:4513:2: iv_ruleXVariableDeclaration= ruleXVariableDeclaration EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXVariableDeclarationRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXVariableDeclaration=ruleXVariableDeclaration();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXVariableDeclaration; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXVariableDeclaration"
+
+
+    // $ANTLR start "ruleXVariableDeclaration"
+    // InternalOXtype.g:4519:1: ruleXVariableDeclaration returns [EObject current=null] : ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) ;
+    public final EObject ruleXVariableDeclaration() throws RecognitionException {
+        EObject current = null;
+
+        Token lv_writeable_1_0=null;
+        Token otherlv_2=null;
+        Token otherlv_6=null;
+        EObject lv_type_3_0 = null;
+
+        AntlrDatatypeRuleToken lv_name_4_0 = null;
+
+        AntlrDatatypeRuleToken lv_name_5_0 = null;
+
+        EObject lv_right_7_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4525:2: ( ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? ) )
+            // InternalOXtype.g:4526:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? )
+            {
+            // InternalOXtype.g:4526:2: ( () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )? )
+            // InternalOXtype.g:4527:3: () ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' ) ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) ) (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )?
+            {
+            // InternalOXtype.g:4527:3: ()
+            // InternalOXtype.g:4528:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXVariableDeclarationAccess().getXVariableDeclarationAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:4534:3: ( ( (lv_writeable_1_0= 'var' ) ) | otherlv_2= 'val' )
+            int alt79=2;
+            int LA79_0 = input.LA(1);
+
+            if ( (LA79_0==72) ) {
+                alt79=1;
+            }
+            else if ( (LA79_0==73) ) {
+                alt79=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 79, 0, input);
+
+                throw nvae;
+            }
+            switch (alt79) {
+                case 1 :
+                    // InternalOXtype.g:4535:4: ( (lv_writeable_1_0= 'var' ) )
+                    {
+                    // InternalOXtype.g:4535:4: ( (lv_writeable_1_0= 'var' ) )
+                    // InternalOXtype.g:4536:5: (lv_writeable_1_0= 'var' )
+                    {
+                    // InternalOXtype.g:4536:5: (lv_writeable_1_0= 'var' )
+                    // InternalOXtype.g:4537:6: lv_writeable_1_0= 'var'
+                    {
+                    lv_writeable_1_0=(Token)match(input,72,FOLLOW_26); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(lv_writeable_1_0, grammarAccess.getXVariableDeclarationAccess().getWriteableVarKeyword_1_0_0());
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXVariableDeclarationRule());
+                      						}
+                      						setWithLastConsumed(current, "writeable", true, "var");
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:4550:4: otherlv_2= 'val'
+                    {
+                    otherlv_2=(Token)match(input,73,FOLLOW_26); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_2, grammarAccess.getXVariableDeclarationAccess().getValKeyword_1_1());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:4555:3: ( ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) ) | ( (lv_name_5_0= ruleValidID ) ) )
+            int alt80=2;
+            int LA80_0 = input.LA(1);
+
+            if ( (LA80_0==RULE_ID) ) {
+                int LA80_1 = input.LA(2);
+
+                if ( (synpred35_InternalOXtype()) ) {
+                    alt80=1;
+                }
+                else if ( (true) ) {
+                    alt80=2;
+                }
+                else {
+                    if (state.backtracking>0) {state.failed=true; return current;}
+                    NoViableAltException nvae =
+                        new NoViableAltException("", 80, 1, input);
+
+                    throw nvae;
+                }
+            }
+            else if ( (LA80_0==20) && (synpred35_InternalOXtype())) {
+                alt80=1;
+            }
+            else if ( (LA80_0==45) && (synpred35_InternalOXtype())) {
+                alt80=1;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 80, 0, input);
+
+                throw nvae;
+            }
+            switch (alt80) {
+                case 1 :
+                    // InternalOXtype.g:4556:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) )
+                    {
+                    // InternalOXtype.g:4556:4: ( ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) ) )
+                    // InternalOXtype.g:4557:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )=> ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) )
+                    {
+                    // InternalOXtype.g:4570:5: ( ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) ) )
+                    // InternalOXtype.g:4571:6: ( (lv_type_3_0= ruleJvmTypeReference ) ) ( (lv_name_4_0= ruleValidID ) )
+                    {
+                    // InternalOXtype.g:4571:6: ( (lv_type_3_0= ruleJvmTypeReference ) )
+                    // InternalOXtype.g:4572:7: (lv_type_3_0= ruleJvmTypeReference )
+                    {
+                    // InternalOXtype.g:4572:7: (lv_type_3_0= ruleJvmTypeReference )
+                    // InternalOXtype.g:4573:8: lv_type_3_0= ruleJvmTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      								newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getTypeJvmTypeReferenceParserRuleCall_2_0_0_0_0());
+                      							
+                    }
+                    pushFollow(FOLLOW_7);
+                    lv_type_3_0=ruleJvmTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      								if (current==null) {
+                      									current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+                      								}
+                      								set(
+                      									current,
+                      									"type",
+                      									lv_type_3_0,
+                      									"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+                      								afterParserOrEnumRuleCall();
+                      							
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:4590:6: ( (lv_name_4_0= ruleValidID ) )
+                    // InternalOXtype.g:4591:7: (lv_name_4_0= ruleValidID )
+                    {
+                    // InternalOXtype.g:4591:7: (lv_name_4_0= ruleValidID )
+                    // InternalOXtype.g:4592:8: lv_name_4_0= ruleValidID
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      								newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_0_0_1_0());
+                      							
+                    }
+                    pushFollow(FOLLOW_68);
+                    lv_name_4_0=ruleValidID();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      								if (current==null) {
+                      									current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+                      								}
+                      								set(
+                      									current,
+                      									"name",
+                      									lv_name_4_0,
+                      									"org.eclipse.xtext.xbase.Xtype.ValidID");
+                      								afterParserOrEnumRuleCall();
+                      							
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:4612:4: ( (lv_name_5_0= ruleValidID ) )
+                    {
+                    // InternalOXtype.g:4612:4: ( (lv_name_5_0= ruleValidID ) )
+                    // InternalOXtype.g:4613:5: (lv_name_5_0= ruleValidID )
+                    {
+                    // InternalOXtype.g:4613:5: (lv_name_5_0= ruleValidID )
+                    // InternalOXtype.g:4614:6: lv_name_5_0= ruleValidID
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getNameValidIDParserRuleCall_2_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_68);
+                    lv_name_5_0=ruleValidID();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+                      						}
+                      						set(
+                      							current,
+                      							"name",
+                      							lv_name_5_0,
+                      							"org.eclipse.xtext.xbase.Xtype.ValidID");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:4632:3: (otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) ) )?
+            int alt81=2;
+            int LA81_0 = input.LA(1);
+
+            if ( (LA81_0==23) ) {
+                alt81=1;
+            }
+            switch (alt81) {
+                case 1 :
+                    // InternalOXtype.g:4633:4: otherlv_6= '=' ( (lv_right_7_0= ruleXExpression ) )
+                    {
+                    otherlv_6=(Token)match(input,23,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_6, grammarAccess.getXVariableDeclarationAccess().getEqualsSignKeyword_3_0());
+                      			
+                    }
+                    // InternalOXtype.g:4637:4: ( (lv_right_7_0= ruleXExpression ) )
+                    // InternalOXtype.g:4638:5: (lv_right_7_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:4638:5: (lv_right_7_0= ruleXExpression )
+                    // InternalOXtype.g:4639:6: lv_right_7_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXVariableDeclarationAccess().getRightXExpressionParserRuleCall_3_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_right_7_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXVariableDeclarationRule());
+                      						}
+                      						set(
+                      							current,
+                      							"right",
+                      							lv_right_7_0,
+                      							"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXVariableDeclaration"
+
+
+    // $ANTLR start "entryRuleJvmFormalParameter"
+    // InternalOXtype.g:4661:1: entryRuleJvmFormalParameter returns [EObject current=null] : iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF ;
+    public final EObject entryRuleJvmFormalParameter() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmFormalParameter = null;
+
+
+        try {
+            // InternalOXtype.g:4661:59: (iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF )
+            // InternalOXtype.g:4662:2: iv_ruleJvmFormalParameter= ruleJvmFormalParameter EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmFormalParameterRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmFormalParameter=ruleJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmFormalParameter; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmFormalParameter"
+
+
+    // $ANTLR start "ruleJvmFormalParameter"
+    // InternalOXtype.g:4668:1: ruleJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) ;
+    public final EObject ruleJvmFormalParameter() throws RecognitionException {
+        EObject current = null;
+
+        EObject lv_parameterType_0_0 = null;
+
+        AntlrDatatypeRuleToken lv_name_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4674:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) ) )
+            // InternalOXtype.g:4675:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) )
+            {
+            // InternalOXtype.g:4675:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) ) )
+            // InternalOXtype.g:4676:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )? ( (lv_name_1_0= ruleValidID ) )
+            {
+            // InternalOXtype.g:4676:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )?
+            int alt82=2;
+            int LA82_0 = input.LA(1);
+
+            if ( (LA82_0==RULE_ID) ) {
+                int LA82_1 = input.LA(2);
+
+                if ( (LA82_1==RULE_ID||LA82_1==25||LA82_1==32||LA82_1==57) ) {
+                    alt82=1;
+                }
+            }
+            else if ( (LA82_0==20||LA82_0==45) ) {
+                alt82=1;
+            }
+            switch (alt82) {
+                case 1 :
+                    // InternalOXtype.g:4677:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+                    {
+                    // InternalOXtype.g:4677:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+                    // InternalOXtype.g:4678:5: lv_parameterType_0_0= ruleJvmTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+                      				
+                    }
+                    pushFollow(FOLLOW_7);
+                    lv_parameterType_0_0=ruleJvmTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					if (current==null) {
+                      						current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+                      					}
+                      					set(
+                      						current,
+                      						"parameterType",
+                      						lv_parameterType_0_0,
+                      						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+                      					afterParserOrEnumRuleCall();
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:4695:3: ( (lv_name_1_0= ruleValidID ) )
+            // InternalOXtype.g:4696:4: (lv_name_1_0= ruleValidID )
+            {
+            // InternalOXtype.g:4696:4: (lv_name_1_0= ruleValidID )
+            // InternalOXtype.g:4697:5: lv_name_1_0= ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_name_1_0=ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getJvmFormalParameterRule());
+              					}
+              					set(
+              						current,
+              						"name",
+              						lv_name_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.ValidID");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmFormalParameter"
+
+
+    // $ANTLR start "entryRuleFullJvmFormalParameter"
+    // InternalOXtype.g:4718:1: entryRuleFullJvmFormalParameter returns [EObject current=null] : iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF ;
+    public final EObject entryRuleFullJvmFormalParameter() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleFullJvmFormalParameter = null;
+
+
+        try {
+            // InternalOXtype.g:4718:63: (iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF )
+            // InternalOXtype.g:4719:2: iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleFullJvmFormalParameter; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleFullJvmFormalParameter"
+
+
+    // $ANTLR start "ruleFullJvmFormalParameter"
+    // InternalOXtype.g:4725:1: ruleFullJvmFormalParameter returns [EObject current=null] : ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) ;
+    public final EObject ruleFullJvmFormalParameter() throws RecognitionException {
+        EObject current = null;
+
+        EObject lv_parameterType_0_0 = null;
+
+        AntlrDatatypeRuleToken lv_name_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4731:2: ( ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) ) )
+            // InternalOXtype.g:4732:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) )
+            {
+            // InternalOXtype.g:4732:2: ( ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) ) )
+            // InternalOXtype.g:4733:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) ) ( (lv_name_1_0= ruleValidID ) )
+            {
+            // InternalOXtype.g:4733:3: ( (lv_parameterType_0_0= ruleJvmTypeReference ) )
+            // InternalOXtype.g:4734:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:4734:4: (lv_parameterType_0_0= ruleJvmTypeReference )
+            // InternalOXtype.g:4735:5: lv_parameterType_0_0= ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getParameterTypeJvmTypeReferenceParserRuleCall_0_0());
+              				
+            }
+            pushFollow(FOLLOW_7);
+            lv_parameterType_0_0=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+              					}
+              					set(
+              						current,
+              						"parameterType",
+              						lv_parameterType_0_0,
+              						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:4752:3: ( (lv_name_1_0= ruleValidID ) )
+            // InternalOXtype.g:4753:4: (lv_name_1_0= ruleValidID )
+            {
+            // InternalOXtype.g:4753:4: (lv_name_1_0= ruleValidID )
+            // InternalOXtype.g:4754:5: lv_name_1_0= ruleValidID
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getFullJvmFormalParameterAccess().getNameValidIDParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_name_1_0=ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getFullJvmFormalParameterRule());
+              					}
+              					set(
+              						current,
+              						"name",
+              						lv_name_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.ValidID");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleFullJvmFormalParameter"
+
+
+    // $ANTLR start "entryRuleXFeatureCall"
+    // InternalOXtype.g:4775:1: entryRuleXFeatureCall returns [EObject current=null] : iv_ruleXFeatureCall= ruleXFeatureCall EOF ;
+    public final EObject entryRuleXFeatureCall() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXFeatureCall = null;
+
+
+        try {
+            // InternalOXtype.g:4775:53: (iv_ruleXFeatureCall= ruleXFeatureCall EOF )
+            // InternalOXtype.g:4776:2: iv_ruleXFeatureCall= ruleXFeatureCall EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXFeatureCallRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXFeatureCall=ruleXFeatureCall();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXFeatureCall; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXFeatureCall"
+
+
+    // $ANTLR start "ruleXFeatureCall"
+    // InternalOXtype.g:4782:1: ruleXFeatureCall returns [EObject current=null] : ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) ;
+    public final EObject ruleXFeatureCall() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token lv_explicitOperationCall_7_0=null;
+        Token otherlv_10=null;
+        Token otherlv_12=null;
+        EObject lv_typeArguments_2_0 = null;
+
+        EObject lv_typeArguments_4_0 = null;
+
+        EObject lv_featureCallArguments_8_0 = null;
+
+        EObject lv_featureCallArguments_9_0 = null;
+
+        EObject lv_featureCallArguments_11_0 = null;
+
+        EObject lv_featureCallArguments_13_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:4788:2: ( ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? ) )
+            // InternalOXtype.g:4789:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? )
+            {
+            // InternalOXtype.g:4789:2: ( () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )? )
+            // InternalOXtype.g:4790:3: () (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )? ( ( ruleIdOrSuper ) ) ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )? ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?
+            {
+            // InternalOXtype.g:4790:3: ()
+            // InternalOXtype.g:4791:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXFeatureCallAccess().getXFeatureCallAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:4797:3: (otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' )?
+            int alt84=2;
+            int LA84_0 = input.LA(1);
+
+            if ( (LA84_0==32) ) {
+                alt84=1;
+            }
+            switch (alt84) {
+                case 1 :
+                    // InternalOXtype.g:4798:4: otherlv_1= '<' ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>'
+                    {
+                    otherlv_1=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_1, grammarAccess.getXFeatureCallAccess().getLessThanSignKeyword_1_0());
+                      			
+                    }
+                    // InternalOXtype.g:4802:4: ( (lv_typeArguments_2_0= ruleJvmArgumentTypeReference ) )
+                    // InternalOXtype.g:4803:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference )
+                    {
+                    // InternalOXtype.g:4803:5: (lv_typeArguments_2_0= ruleJvmArgumentTypeReference )
+                    // InternalOXtype.g:4804:6: lv_typeArguments_2_0= ruleJvmArgumentTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_39);
+                    lv_typeArguments_2_0=ruleJvmArgumentTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+                      						}
+                      						add(
+                      							current,
+                      							"typeArguments",
+                      							lv_typeArguments_2_0,
+                      							"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:4821:4: (otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) )*
+                    loop83:
+                    do {
+                        int alt83=2;
+                        int LA83_0 = input.LA(1);
+
+                        if ( (LA83_0==21) ) {
+                            alt83=1;
+                        }
+
+
+                        switch (alt83) {
+                    	case 1 :
+                    	    // InternalOXtype.g:4822:5: otherlv_3= ',' ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) )
+                    	    {
+                    	    otherlv_3=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_3, grammarAccess.getXFeatureCallAccess().getCommaKeyword_1_2_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:4826:5: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) )
+                    	    // InternalOXtype.g:4827:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+                    	    {
+                    	    // InternalOXtype.g:4827:6: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+                    	    // InternalOXtype.g:4828:7: lv_typeArguments_4_0= ruleJvmArgumentTypeReference
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXFeatureCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_39);
+                    	    lv_typeArguments_4_0=ruleJvmArgumentTypeReference();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"typeArguments",
+                    	      								lv_typeArguments_4_0,
+                    	      								"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop83;
+                        }
+                    } while (true);
+
+                    otherlv_5=(Token)match(input,33,FOLLOW_37); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_5, grammarAccess.getXFeatureCallAccess().getGreaterThanSignKeyword_1_3());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:4851:3: ( ( ruleIdOrSuper ) )
+            // InternalOXtype.g:4852:4: ( ruleIdOrSuper )
+            {
+            // InternalOXtype.g:4852:4: ( ruleIdOrSuper )
+            // InternalOXtype.g:4853:5: ruleIdOrSuper
+            {
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElement(grammarAccess.getXFeatureCallRule());
+              					}
+              				
+            }
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureJvmIdentifiableElementCrossReference_2_0());
+              				
+            }
+            pushFollow(FOLLOW_69);
+            ruleIdOrSuper();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:4867:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?
+            int alt87=2;
+            alt87 = dfa87.predict(input);
+            switch (alt87) {
+                case 1 :
+                    // InternalOXtype.g:4868:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')'
+                    {
+                    // InternalOXtype.g:4868:4: ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) )
+                    // InternalOXtype.g:4869:5: ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' )
+                    {
+                    // InternalOXtype.g:4873:5: (lv_explicitOperationCall_7_0= '(' )
+                    // InternalOXtype.g:4874:6: lv_explicitOperationCall_7_0= '('
+                    {
+                    lv_explicitOperationCall_7_0=(Token)match(input,20,FOLLOW_41); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(lv_explicitOperationCall_7_0, grammarAccess.getXFeatureCallAccess().getExplicitOperationCallLeftParenthesisKeyword_3_0_0());
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXFeatureCallRule());
+                      						}
+                      						setWithLastConsumed(current, "explicitOperationCall", true, "(");
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:4886:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?
+                    int alt86=3;
+                    alt86 = dfa86.predict(input);
+                    switch (alt86) {
+                        case 1 :
+                            // InternalOXtype.g:4887:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) )
+                            {
+                            // InternalOXtype.g:4887:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) )
+                            // InternalOXtype.g:4888:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure )
+                            {
+                            // InternalOXtype.g:4913:6: (lv_featureCallArguments_8_0= ruleXShortClosure )
+                            // InternalOXtype.g:4914:7: lv_featureCallArguments_8_0= ruleXShortClosure
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXShortClosureParserRuleCall_3_1_0_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_11);
+                            lv_featureCallArguments_8_0=ruleXShortClosure();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+                              							}
+                              							add(
+                              								current,
+                              								"featureCallArguments",
+                              								lv_featureCallArguments_8_0,
+                              								"org.eclipse.xtext.xbase.Xbase.XShortClosure");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:4932:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* )
+                            {
+                            // InternalOXtype.g:4932:5: ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* )
+                            // InternalOXtype.g:4933:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )*
+                            {
+                            // InternalOXtype.g:4933:6: ( (lv_featureCallArguments_9_0= ruleXExpression ) )
+                            // InternalOXtype.g:4934:7: (lv_featureCallArguments_9_0= ruleXExpression )
+                            {
+                            // InternalOXtype.g:4934:7: (lv_featureCallArguments_9_0= ruleXExpression )
+                            // InternalOXtype.g:4935:8: lv_featureCallArguments_9_0= ruleXExpression
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_0_0());
+                              							
+                            }
+                            pushFollow(FOLLOW_10);
+                            lv_featureCallArguments_9_0=ruleXExpression();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+                              								}
+                              								add(
+                              									current,
+                              									"featureCallArguments",
+                              									lv_featureCallArguments_9_0,
+                              									"org.eclipse.xtext.xbase.Xbase.XExpression");
+                              								afterParserOrEnumRuleCall();
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:4952:6: (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )*
+                            loop85:
+                            do {
+                                int alt85=2;
+                                int LA85_0 = input.LA(1);
+
+                                if ( (LA85_0==21) ) {
+                                    alt85=1;
+                                }
+
+
+                                switch (alt85) {
+                            	case 1 :
+                            	    // InternalOXtype.g:4953:7: otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) )
+                            	    {
+                            	    otherlv_10=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      							newLeafNode(otherlv_10, grammarAccess.getXFeatureCallAccess().getCommaKeyword_3_1_1_1_0());
+                            	      						
+                            	    }
+                            	    // InternalOXtype.g:4957:7: ( (lv_featureCallArguments_11_0= ruleXExpression ) )
+                            	    // InternalOXtype.g:4958:8: (lv_featureCallArguments_11_0= ruleXExpression )
+                            	    {
+                            	    // InternalOXtype.g:4958:8: (lv_featureCallArguments_11_0= ruleXExpression )
+                            	    // InternalOXtype.g:4959:9: lv_featureCallArguments_11_0= ruleXExpression
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXExpressionParserRuleCall_3_1_1_1_1_0());
+                            	      								
+                            	    }
+                            	    pushFollow(FOLLOW_10);
+                            	    lv_featureCallArguments_11_0=ruleXExpression();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									if (current==null) {
+                            	      										current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+                            	      									}
+                            	      									add(
+                            	      										current,
+                            	      										"featureCallArguments",
+                            	      										lv_featureCallArguments_11_0,
+                            	      										"org.eclipse.xtext.xbase.Xbase.XExpression");
+                            	      									afterParserOrEnumRuleCall();
+                            	      								
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop85;
+                                }
+                            } while (true);
+
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+                    otherlv_12=(Token)match(input,22,FOLLOW_70); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_12, grammarAccess.getXFeatureCallAccess().getRightParenthesisKeyword_3_2());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:4984:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?
+            int alt88=2;
+            alt88 = dfa88.predict(input);
+            switch (alt88) {
+                case 1 :
+                    // InternalOXtype.g:4985:4: ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure )
+                    {
+                    // InternalOXtype.g:4991:4: (lv_featureCallArguments_13_0= ruleXClosure )
+                    // InternalOXtype.g:4992:5: lv_featureCallArguments_13_0= ruleXClosure
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					newCompositeNode(grammarAccess.getXFeatureCallAccess().getFeatureCallArgumentsXClosureParserRuleCall_4_0());
+                      				
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_featureCallArguments_13_0=ruleXClosure();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					if (current==null) {
+                      						current = createModelElementForParent(grammarAccess.getXFeatureCallRule());
+                      					}
+                      					add(
+                      						current,
+                      						"featureCallArguments",
+                      						lv_featureCallArguments_13_0,
+                      						"org.eclipse.xtext.xbase.Xbase.XClosure");
+                      					afterParserOrEnumRuleCall();
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXFeatureCall"
+
+
+    // $ANTLR start "entryRuleFeatureCallID"
+    // InternalOXtype.g:5013:1: entryRuleFeatureCallID returns [String current=null] : iv_ruleFeatureCallID= ruleFeatureCallID EOF ;
+    public final String entryRuleFeatureCallID() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleFeatureCallID = null;
+
+
+        try {
+            // InternalOXtype.g:5013:53: (iv_ruleFeatureCallID= ruleFeatureCallID EOF )
+            // InternalOXtype.g:5014:2: iv_ruleFeatureCallID= ruleFeatureCallID EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getFeatureCallIDRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleFeatureCallID=ruleFeatureCallID();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleFeatureCallID.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleFeatureCallID"
+
+
+    // $ANTLR start "ruleFeatureCallID"
+    // InternalOXtype.g:5020:1: ruleFeatureCallID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) ;
+    public final AntlrDatatypeRuleToken ruleFeatureCallID() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+        AntlrDatatypeRuleToken this_ValidID_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5026:2: ( (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' ) )
+            // InternalOXtype.g:5027:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' )
+            {
+            // InternalOXtype.g:5027:2: (this_ValidID_0= ruleValidID | kw= 'extends' | kw= 'static' | kw= 'import' | kw= 'extension' )
+            int alt89=5;
+            switch ( input.LA(1) ) {
+            case RULE_ID:
+                {
+                alt89=1;
+                }
+                break;
+            case 74:
+                {
+                alt89=2;
+                }
+                break;
+            case 14:
+                {
+                alt89=3;
+                }
+                break;
+            case 13:
+                {
+                alt89=4;
+                }
+                break;
+            case 15:
+                {
+                alt89=5;
+                }
+                break;
+            default:
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 89, 0, input);
+
+                throw nvae;
+            }
+
+            switch (alt89) {
+                case 1 :
+                    // InternalOXtype.g:5028:3: this_ValidID_0= ruleValidID
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getFeatureCallIDAccess().getValidIDParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_ValidID_0=ruleValidID();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(this_ValidID_0);
+                      		
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:5039:3: kw= 'extends'
+                    {
+                    kw=(Token)match(input,74,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtendsKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+                case 3 :
+                    // InternalOXtype.g:5045:3: kw= 'static'
+                    {
+                    kw=(Token)match(input,14,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getStaticKeyword_2());
+                      		
+                    }
+
+                    }
+                    break;
+                case 4 :
+                    // InternalOXtype.g:5051:3: kw= 'import'
+                    {
+                    kw=(Token)match(input,13,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getImportKeyword_3());
+                      		
+                    }
+
+                    }
+                    break;
+                case 5 :
+                    // InternalOXtype.g:5057:3: kw= 'extension'
+                    {
+                    kw=(Token)match(input,15,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getFeatureCallIDAccess().getExtensionKeyword_4());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleFeatureCallID"
+
+
+    // $ANTLR start "entryRuleIdOrSuper"
+    // InternalOXtype.g:5066:1: entryRuleIdOrSuper returns [String current=null] : iv_ruleIdOrSuper= ruleIdOrSuper EOF ;
+    public final String entryRuleIdOrSuper() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleIdOrSuper = null;
+
+
+        try {
+            // InternalOXtype.g:5066:49: (iv_ruleIdOrSuper= ruleIdOrSuper EOF )
+            // InternalOXtype.g:5067:2: iv_ruleIdOrSuper= ruleIdOrSuper EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getIdOrSuperRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleIdOrSuper=ruleIdOrSuper();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleIdOrSuper.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleIdOrSuper"
+
+
+    // $ANTLR start "ruleIdOrSuper"
+    // InternalOXtype.g:5073:1: ruleIdOrSuper returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) ;
+    public final AntlrDatatypeRuleToken ruleIdOrSuper() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+        AntlrDatatypeRuleToken this_FeatureCallID_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5079:2: ( (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' ) )
+            // InternalOXtype.g:5080:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' )
+            {
+            // InternalOXtype.g:5080:2: (this_FeatureCallID_0= ruleFeatureCallID | kw= 'super' )
+            int alt90=2;
+            int LA90_0 = input.LA(1);
+
+            if ( (LA90_0==RULE_ID||(LA90_0>=13 && LA90_0<=15)||LA90_0==74) ) {
+                alt90=1;
+            }
+            else if ( (LA90_0==75) ) {
+                alt90=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 90, 0, input);
+
+                throw nvae;
+            }
+            switch (alt90) {
+                case 1 :
+                    // InternalOXtype.g:5081:3: this_FeatureCallID_0= ruleFeatureCallID
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getIdOrSuperAccess().getFeatureCallIDParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_FeatureCallID_0=ruleFeatureCallID();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(this_FeatureCallID_0);
+                      		
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:5092:3: kw= 'super'
+                    {
+                    kw=(Token)match(input,75,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(kw);
+                      			newLeafNode(kw, grammarAccess.getIdOrSuperAccess().getSuperKeyword_1());
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleIdOrSuper"
+
+
+    // $ANTLR start "entryRuleXConstructorCall"
+    // InternalOXtype.g:5101:1: entryRuleXConstructorCall returns [EObject current=null] : iv_ruleXConstructorCall= ruleXConstructorCall EOF ;
+    public final EObject entryRuleXConstructorCall() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXConstructorCall = null;
+
+
+        try {
+            // InternalOXtype.g:5101:57: (iv_ruleXConstructorCall= ruleXConstructorCall EOF )
+            // InternalOXtype.g:5102:2: iv_ruleXConstructorCall= ruleXConstructorCall EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXConstructorCallRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXConstructorCall=ruleXConstructorCall();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXConstructorCall; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXConstructorCall"
+
+
+    // $ANTLR start "ruleXConstructorCall"
+    // InternalOXtype.g:5108:1: ruleXConstructorCall returns [EObject current=null] : ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) ;
+    public final EObject ruleXConstructorCall() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token otherlv_7=null;
+        Token lv_explicitConstructorCall_8_0=null;
+        Token otherlv_11=null;
+        Token otherlv_13=null;
+        EObject lv_typeArguments_4_0 = null;
+
+        EObject lv_typeArguments_6_0 = null;
+
+        EObject lv_arguments_9_0 = null;
+
+        EObject lv_arguments_10_0 = null;
+
+        EObject lv_arguments_12_0 = null;
+
+        EObject lv_arguments_14_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5114:2: ( ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? ) )
+            // InternalOXtype.g:5115:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? )
+            {
+            // InternalOXtype.g:5115:2: ( () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )? )
+            // InternalOXtype.g:5116:3: () otherlv_1= 'new' ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )? ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )? ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?
+            {
+            // InternalOXtype.g:5116:3: ()
+            // InternalOXtype.g:5117:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXConstructorCallAccess().getXConstructorCallAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,76,FOLLOW_7); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXConstructorCallAccess().getNewKeyword_1());
+              		
+            }
+            // InternalOXtype.g:5127:3: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:5128:4: ( ruleQualifiedName )
+            {
+            // InternalOXtype.g:5128:4: ( ruleQualifiedName )
+            // InternalOXtype.g:5129:5: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElement(grammarAccess.getXConstructorCallRule());
+              					}
+              				
+            }
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXConstructorCallAccess().getConstructorJvmConstructorCrossReference_2_0());
+              				
+            }
+            pushFollow(FOLLOW_71);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:5143:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?
+            int alt92=2;
+            alt92 = dfa92.predict(input);
+            switch (alt92) {
+                case 1 :
+                    // InternalOXtype.g:5144:4: ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>'
+                    {
+                    // InternalOXtype.g:5144:4: ( ( '<' )=>otherlv_3= '<' )
+                    // InternalOXtype.g:5145:5: ( '<' )=>otherlv_3= '<'
+                    {
+                    otherlv_3=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_3, grammarAccess.getXConstructorCallAccess().getLessThanSignKeyword_3_0());
+                      				
+                    }
+
+                    }
+
+                    // InternalOXtype.g:5151:4: ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) )
+                    // InternalOXtype.g:5152:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+                    {
+                    // InternalOXtype.g:5152:5: (lv_typeArguments_4_0= ruleJvmArgumentTypeReference )
+                    // InternalOXtype.g:5153:6: lv_typeArguments_4_0= ruleJvmArgumentTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_39);
+                    lv_typeArguments_4_0=ruleJvmArgumentTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+                      						}
+                      						add(
+                      							current,
+                      							"typeArguments",
+                      							lv_typeArguments_4_0,
+                      							"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:5170:4: (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )*
+                    loop91:
+                    do {
+                        int alt91=2;
+                        int LA91_0 = input.LA(1);
+
+                        if ( (LA91_0==21) ) {
+                            alt91=1;
+                        }
+
+
+                        switch (alt91) {
+                    	case 1 :
+                    	    // InternalOXtype.g:5171:5: otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) )
+                    	    {
+                    	    otherlv_5=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_5, grammarAccess.getXConstructorCallAccess().getCommaKeyword_3_2_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:5175:5: ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) )
+                    	    // InternalOXtype.g:5176:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference )
+                    	    {
+                    	    // InternalOXtype.g:5176:6: (lv_typeArguments_6_0= ruleJvmArgumentTypeReference )
+                    	    // InternalOXtype.g:5177:7: lv_typeArguments_6_0= ruleJvmArgumentTypeReference
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXConstructorCallAccess().getTypeArgumentsJvmArgumentTypeReferenceParserRuleCall_3_2_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_39);
+                    	    lv_typeArguments_6_0=ruleJvmArgumentTypeReference();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"typeArguments",
+                    	      								lv_typeArguments_6_0,
+                    	      								"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop91;
+                        }
+                    } while (true);
+
+                    otherlv_7=(Token)match(input,33,FOLLOW_69); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_7, grammarAccess.getXConstructorCallAccess().getGreaterThanSignKeyword_3_3());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:5200:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?
+            int alt95=2;
+            alt95 = dfa95.predict(input);
+            switch (alt95) {
+                case 1 :
+                    // InternalOXtype.g:5201:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')'
+                    {
+                    // InternalOXtype.g:5201:4: ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) )
+                    // InternalOXtype.g:5202:5: ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' )
+                    {
+                    // InternalOXtype.g:5206:5: (lv_explicitConstructorCall_8_0= '(' )
+                    // InternalOXtype.g:5207:6: lv_explicitConstructorCall_8_0= '('
+                    {
+                    lv_explicitConstructorCall_8_0=(Token)match(input,20,FOLLOW_41); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(lv_explicitConstructorCall_8_0, grammarAccess.getXConstructorCallAccess().getExplicitConstructorCallLeftParenthesisKeyword_4_0_0());
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXConstructorCallRule());
+                      						}
+                      						setWithLastConsumed(current, "explicitConstructorCall", true, "(");
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:5219:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?
+                    int alt94=3;
+                    alt94 = dfa94.predict(input);
+                    switch (alt94) {
+                        case 1 :
+                            // InternalOXtype.g:5220:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) )
+                            {
+                            // InternalOXtype.g:5220:5: ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) )
+                            // InternalOXtype.g:5221:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure )
+                            {
+                            // InternalOXtype.g:5246:6: (lv_arguments_9_0= ruleXShortClosure )
+                            // InternalOXtype.g:5247:7: lv_arguments_9_0= ruleXShortClosure
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXShortClosureParserRuleCall_4_1_0_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_11);
+                            lv_arguments_9_0=ruleXShortClosure();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+                              							}
+                              							add(
+                              								current,
+                              								"arguments",
+                              								lv_arguments_9_0,
+                              								"org.eclipse.xtext.xbase.Xbase.XShortClosure");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:5265:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* )
+                            {
+                            // InternalOXtype.g:5265:5: ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* )
+                            // InternalOXtype.g:5266:6: ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )*
+                            {
+                            // InternalOXtype.g:5266:6: ( (lv_arguments_10_0= ruleXExpression ) )
+                            // InternalOXtype.g:5267:7: (lv_arguments_10_0= ruleXExpression )
+                            {
+                            // InternalOXtype.g:5267:7: (lv_arguments_10_0= ruleXExpression )
+                            // InternalOXtype.g:5268:8: lv_arguments_10_0= ruleXExpression
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_0_0());
+                              							
+                            }
+                            pushFollow(FOLLOW_10);
+                            lv_arguments_10_0=ruleXExpression();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+                              								}
+                              								add(
+                              									current,
+                              									"arguments",
+                              									lv_arguments_10_0,
+                              									"org.eclipse.xtext.xbase.Xbase.XExpression");
+                              								afterParserOrEnumRuleCall();
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:5285:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )*
+                            loop93:
+                            do {
+                                int alt93=2;
+                                int LA93_0 = input.LA(1);
+
+                                if ( (LA93_0==21) ) {
+                                    alt93=1;
+                                }
+
+
+                                switch (alt93) {
+                            	case 1 :
+                            	    // InternalOXtype.g:5286:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) )
+                            	    {
+                            	    otherlv_11=(Token)match(input,21,FOLLOW_13); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      							newLeafNode(otherlv_11, grammarAccess.getXConstructorCallAccess().getCommaKeyword_4_1_1_1_0());
+                            	      						
+                            	    }
+                            	    // InternalOXtype.g:5290:7: ( (lv_arguments_12_0= ruleXExpression ) )
+                            	    // InternalOXtype.g:5291:8: (lv_arguments_12_0= ruleXExpression )
+                            	    {
+                            	    // InternalOXtype.g:5291:8: (lv_arguments_12_0= ruleXExpression )
+                            	    // InternalOXtype.g:5292:9: lv_arguments_12_0= ruleXExpression
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXExpressionParserRuleCall_4_1_1_1_1_0());
+                            	      								
+                            	    }
+                            	    pushFollow(FOLLOW_10);
+                            	    lv_arguments_12_0=ruleXExpression();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      									if (current==null) {
+                            	      										current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+                            	      									}
+                            	      									add(
+                            	      										current,
+                            	      										"arguments",
+                            	      										lv_arguments_12_0,
+                            	      										"org.eclipse.xtext.xbase.Xbase.XExpression");
+                            	      									afterParserOrEnumRuleCall();
+                            	      								
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop93;
+                                }
+                            } while (true);
+
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+                    otherlv_13=(Token)match(input,22,FOLLOW_70); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_13, grammarAccess.getXConstructorCallAccess().getRightParenthesisKeyword_4_2());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+            // InternalOXtype.g:5317:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?
+            int alt96=2;
+            alt96 = dfa96.predict(input);
+            switch (alt96) {
+                case 1 :
+                    // InternalOXtype.g:5318:4: ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure )
+                    {
+                    // InternalOXtype.g:5324:4: (lv_arguments_14_0= ruleXClosure )
+                    // InternalOXtype.g:5325:5: lv_arguments_14_0= ruleXClosure
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					newCompositeNode(grammarAccess.getXConstructorCallAccess().getArgumentsXClosureParserRuleCall_5_0());
+                      				
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_arguments_14_0=ruleXClosure();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					if (current==null) {
+                      						current = createModelElementForParent(grammarAccess.getXConstructorCallRule());
+                      					}
+                      					add(
+                      						current,
+                      						"arguments",
+                      						lv_arguments_14_0,
+                      						"org.eclipse.xtext.xbase.Xbase.XClosure");
+                      					afterParserOrEnumRuleCall();
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXConstructorCall"
+
+
+    // $ANTLR start "entryRuleXBooleanLiteral"
+    // InternalOXtype.g:5346:1: entryRuleXBooleanLiteral returns [EObject current=null] : iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF ;
+    public final EObject entryRuleXBooleanLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXBooleanLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:5346:56: (iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF )
+            // InternalOXtype.g:5347:2: iv_ruleXBooleanLiteral= ruleXBooleanLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXBooleanLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXBooleanLiteral=ruleXBooleanLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXBooleanLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXBooleanLiteral"
+
+
+    // $ANTLR start "ruleXBooleanLiteral"
+    // InternalOXtype.g:5353:1: ruleXBooleanLiteral returns [EObject current=null] : ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) ;
+    public final EObject ruleXBooleanLiteral() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token lv_isTrue_2_0=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5359:2: ( ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) ) )
+            // InternalOXtype.g:5360:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            {
+            // InternalOXtype.g:5360:2: ( () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) ) )
+            // InternalOXtype.g:5361:3: () (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            {
+            // InternalOXtype.g:5361:3: ()
+            // InternalOXtype.g:5362:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXBooleanLiteralAccess().getXBooleanLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:5368:3: (otherlv_1= 'false' | ( (lv_isTrue_2_0= 'true' ) ) )
+            int alt97=2;
+            int LA97_0 = input.LA(1);
+
+            if ( (LA97_0==77) ) {
+                alt97=1;
+            }
+            else if ( (LA97_0==78) ) {
+                alt97=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 97, 0, input);
+
+                throw nvae;
+            }
+            switch (alt97) {
+                case 1 :
+                    // InternalOXtype.g:5369:4: otherlv_1= 'false'
+                    {
+                    otherlv_1=(Token)match(input,77,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_1, grammarAccess.getXBooleanLiteralAccess().getFalseKeyword_1_0());
+                      			
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:5374:4: ( (lv_isTrue_2_0= 'true' ) )
+                    {
+                    // InternalOXtype.g:5374:4: ( (lv_isTrue_2_0= 'true' ) )
+                    // InternalOXtype.g:5375:5: (lv_isTrue_2_0= 'true' )
+                    {
+                    // InternalOXtype.g:5375:5: (lv_isTrue_2_0= 'true' )
+                    // InternalOXtype.g:5376:6: lv_isTrue_2_0= 'true'
+                    {
+                    lv_isTrue_2_0=(Token)match(input,78,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						newLeafNode(lv_isTrue_2_0, grammarAccess.getXBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0());
+                      					
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElement(grammarAccess.getXBooleanLiteralRule());
+                      						}
+                      						setWithLastConsumed(current, "isTrue", true, "true");
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXBooleanLiteral"
+
+
+    // $ANTLR start "entryRuleXNullLiteral"
+    // InternalOXtype.g:5393:1: entryRuleXNullLiteral returns [EObject current=null] : iv_ruleXNullLiteral= ruleXNullLiteral EOF ;
+    public final EObject entryRuleXNullLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXNullLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:5393:53: (iv_ruleXNullLiteral= ruleXNullLiteral EOF )
+            // InternalOXtype.g:5394:2: iv_ruleXNullLiteral= ruleXNullLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXNullLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXNullLiteral=ruleXNullLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXNullLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXNullLiteral"
+
+
+    // $ANTLR start "ruleXNullLiteral"
+    // InternalOXtype.g:5400:1: ruleXNullLiteral returns [EObject current=null] : ( () otherlv_1= 'null' ) ;
+    public final EObject ruleXNullLiteral() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5406:2: ( ( () otherlv_1= 'null' ) )
+            // InternalOXtype.g:5407:2: ( () otherlv_1= 'null' )
+            {
+            // InternalOXtype.g:5407:2: ( () otherlv_1= 'null' )
+            // InternalOXtype.g:5408:3: () otherlv_1= 'null'
+            {
+            // InternalOXtype.g:5408:3: ()
+            // InternalOXtype.g:5409:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXNullLiteralAccess().getXNullLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,79,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXNullLiteralAccess().getNullKeyword_1());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXNullLiteral"
+
+
+    // $ANTLR start "entryRuleXNumberLiteral"
+    // InternalOXtype.g:5423:1: entryRuleXNumberLiteral returns [EObject current=null] : iv_ruleXNumberLiteral= ruleXNumberLiteral EOF ;
+    public final EObject entryRuleXNumberLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXNumberLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:5423:55: (iv_ruleXNumberLiteral= ruleXNumberLiteral EOF )
+            // InternalOXtype.g:5424:2: iv_ruleXNumberLiteral= ruleXNumberLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXNumberLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXNumberLiteral=ruleXNumberLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXNumberLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXNumberLiteral"
+
+
+    // $ANTLR start "ruleXNumberLiteral"
+    // InternalOXtype.g:5430:1: ruleXNumberLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= ruleNumber ) ) ) ;
+    public final EObject ruleXNumberLiteral() throws RecognitionException {
+        EObject current = null;
+
+        AntlrDatatypeRuleToken lv_value_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5436:2: ( ( () ( (lv_value_1_0= ruleNumber ) ) ) )
+            // InternalOXtype.g:5437:2: ( () ( (lv_value_1_0= ruleNumber ) ) )
+            {
+            // InternalOXtype.g:5437:2: ( () ( (lv_value_1_0= ruleNumber ) ) )
+            // InternalOXtype.g:5438:3: () ( (lv_value_1_0= ruleNumber ) )
+            {
+            // InternalOXtype.g:5438:3: ()
+            // InternalOXtype.g:5439:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXNumberLiteralAccess().getXNumberLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:5445:3: ( (lv_value_1_0= ruleNumber ) )
+            // InternalOXtype.g:5446:4: (lv_value_1_0= ruleNumber )
+            {
+            // InternalOXtype.g:5446:4: (lv_value_1_0= ruleNumber )
+            // InternalOXtype.g:5447:5: lv_value_1_0= ruleNumber
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXNumberLiteralAccess().getValueNumberParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_value_1_0=ruleNumber();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXNumberLiteralRule());
+              					}
+              					set(
+              						current,
+              						"value",
+              						lv_value_1_0,
+              						"org.eclipse.xtext.xbase.Xbase.Number");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXNumberLiteral"
+
+
+    // $ANTLR start "entryRuleXStringLiteral"
+    // InternalOXtype.g:5468:1: entryRuleXStringLiteral returns [EObject current=null] : iv_ruleXStringLiteral= ruleXStringLiteral EOF ;
+    public final EObject entryRuleXStringLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXStringLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:5468:55: (iv_ruleXStringLiteral= ruleXStringLiteral EOF )
+            // InternalOXtype.g:5469:2: iv_ruleXStringLiteral= ruleXStringLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXStringLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXStringLiteral=ruleXStringLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXStringLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXStringLiteral"
+
+
+    // $ANTLR start "ruleXStringLiteral"
+    // InternalOXtype.g:5475:1: ruleXStringLiteral returns [EObject current=null] : ( () ( (lv_value_1_0= RULE_STRING ) ) ) ;
+    public final EObject ruleXStringLiteral() throws RecognitionException {
+        EObject current = null;
+
+        Token lv_value_1_0=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5481:2: ( ( () ( (lv_value_1_0= RULE_STRING ) ) ) )
+            // InternalOXtype.g:5482:2: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            {
+            // InternalOXtype.g:5482:2: ( () ( (lv_value_1_0= RULE_STRING ) ) )
+            // InternalOXtype.g:5483:3: () ( (lv_value_1_0= RULE_STRING ) )
+            {
+            // InternalOXtype.g:5483:3: ()
+            // InternalOXtype.g:5484:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXStringLiteralAccess().getXStringLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            // InternalOXtype.g:5490:3: ( (lv_value_1_0= RULE_STRING ) )
+            // InternalOXtype.g:5491:4: (lv_value_1_0= RULE_STRING )
+            {
+            // InternalOXtype.g:5491:4: (lv_value_1_0= RULE_STRING )
+            // InternalOXtype.g:5492:5: lv_value_1_0= RULE_STRING
+            {
+            lv_value_1_0=(Token)match(input,RULE_STRING,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(lv_value_1_0, grammarAccess.getXStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0());
+              				
+            }
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElement(grammarAccess.getXStringLiteralRule());
+              					}
+              					setWithLastConsumed(
+              						current,
+              						"value",
+              						lv_value_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.STRING");
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXStringLiteral"
+
+
+    // $ANTLR start "entryRuleXTypeLiteral"
+    // InternalOXtype.g:5512:1: entryRuleXTypeLiteral returns [EObject current=null] : iv_ruleXTypeLiteral= ruleXTypeLiteral EOF ;
+    public final EObject entryRuleXTypeLiteral() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXTypeLiteral = null;
+
+
+        try {
+            // InternalOXtype.g:5512:53: (iv_ruleXTypeLiteral= ruleXTypeLiteral EOF )
+            // InternalOXtype.g:5513:2: iv_ruleXTypeLiteral= ruleXTypeLiteral EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXTypeLiteralRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXTypeLiteral=ruleXTypeLiteral();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXTypeLiteral; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXTypeLiteral"
+
+
+    // $ANTLR start "ruleXTypeLiteral"
+    // InternalOXtype.g:5519:1: ruleXTypeLiteral returns [EObject current=null] : ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) ;
+    public final EObject ruleXTypeLiteral() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_5=null;
+        AntlrDatatypeRuleToken lv_arrayDimensions_4_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5525:2: ( ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' ) )
+            // InternalOXtype.g:5526:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' )
+            {
+            // InternalOXtype.g:5526:2: ( () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')' )
+            // InternalOXtype.g:5527:3: () otherlv_1= 'typeof' otherlv_2= '(' ( ( ruleQualifiedName ) ) ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )* otherlv_5= ')'
+            {
+            // InternalOXtype.g:5527:3: ()
+            // InternalOXtype.g:5528:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXTypeLiteralAccess().getXTypeLiteralAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,80,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXTypeLiteralAccess().getTypeofKeyword_1());
+              		
+            }
+            otherlv_2=(Token)match(input,20,FOLLOW_7); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_2, grammarAccess.getXTypeLiteralAccess().getLeftParenthesisKeyword_2());
+              		
+            }
+            // InternalOXtype.g:5542:3: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:5543:4: ( ruleQualifiedName )
+            {
+            // InternalOXtype.g:5543:4: ( ruleQualifiedName )
+            // InternalOXtype.g:5544:5: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElement(grammarAccess.getXTypeLiteralRule());
+              					}
+              				
+            }
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXTypeLiteralAccess().getTypeJvmTypeCrossReference_3_0());
+              				
+            }
+            pushFollow(FOLLOW_72);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:5558:3: ( (lv_arrayDimensions_4_0= ruleArrayBrackets ) )*
+            loop98:
+            do {
+                int alt98=2;
+                int LA98_0 = input.LA(1);
+
+                if ( (LA98_0==25) ) {
+                    alt98=1;
+                }
+
+
+                switch (alt98) {
+            	case 1 :
+            	    // InternalOXtype.g:5559:4: (lv_arrayDimensions_4_0= ruleArrayBrackets )
+            	    {
+            	    // InternalOXtype.g:5559:4: (lv_arrayDimensions_4_0= ruleArrayBrackets )
+            	    // InternalOXtype.g:5560:5: lv_arrayDimensions_4_0= ruleArrayBrackets
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      					newCompositeNode(grammarAccess.getXTypeLiteralAccess().getArrayDimensionsArrayBracketsParserRuleCall_4_0());
+            	      				
+            	    }
+            	    pushFollow(FOLLOW_72);
+            	    lv_arrayDimensions_4_0=ruleArrayBrackets();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      					if (current==null) {
+            	      						current = createModelElementForParent(grammarAccess.getXTypeLiteralRule());
+            	      					}
+            	      					add(
+            	      						current,
+            	      						"arrayDimensions",
+            	      						lv_arrayDimensions_4_0,
+            	      						"org.eclipse.xtext.xbase.Xtype.ArrayBrackets");
+            	      					afterParserOrEnumRuleCall();
+            	      				
+            	    }
+
+            	    }
+
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop98;
+                }
+            } while (true);
+
+            otherlv_5=(Token)match(input,22,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_5, grammarAccess.getXTypeLiteralAccess().getRightParenthesisKeyword_5());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXTypeLiteral"
+
+
+    // $ANTLR start "entryRuleXThrowExpression"
+    // InternalOXtype.g:5585:1: entryRuleXThrowExpression returns [EObject current=null] : iv_ruleXThrowExpression= ruleXThrowExpression EOF ;
+    public final EObject entryRuleXThrowExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXThrowExpression = null;
+
+
+        try {
+            // InternalOXtype.g:5585:57: (iv_ruleXThrowExpression= ruleXThrowExpression EOF )
+            // InternalOXtype.g:5586:2: iv_ruleXThrowExpression= ruleXThrowExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXThrowExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXThrowExpression=ruleXThrowExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXThrowExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXThrowExpression"
+
+
+    // $ANTLR start "ruleXThrowExpression"
+    // InternalOXtype.g:5592:1: ruleXThrowExpression returns [EObject current=null] : ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXThrowExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        EObject lv_expression_2_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5598:2: ( ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:5599:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:5599:2: ( () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) ) )
+            // InternalOXtype.g:5600:3: () otherlv_1= 'throw' ( (lv_expression_2_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:5600:3: ()
+            // InternalOXtype.g:5601:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXThrowExpressionAccess().getXThrowExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,81,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXThrowExpressionAccess().getThrowKeyword_1());
+              		
+            }
+            // InternalOXtype.g:5611:3: ( (lv_expression_2_0= ruleXExpression ) )
+            // InternalOXtype.g:5612:4: (lv_expression_2_0= ruleXExpression )
+            {
+            // InternalOXtype.g:5612:4: (lv_expression_2_0= ruleXExpression )
+            // InternalOXtype.g:5613:5: lv_expression_2_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXThrowExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_expression_2_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXThrowExpressionRule());
+              					}
+              					set(
+              						current,
+              						"expression",
+              						lv_expression_2_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXThrowExpression"
+
+
+    // $ANTLR start "entryRuleXReturnExpression"
+    // InternalOXtype.g:5634:1: entryRuleXReturnExpression returns [EObject current=null] : iv_ruleXReturnExpression= ruleXReturnExpression EOF ;
+    public final EObject entryRuleXReturnExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXReturnExpression = null;
+
+
+        try {
+            // InternalOXtype.g:5634:58: (iv_ruleXReturnExpression= ruleXReturnExpression EOF )
+            // InternalOXtype.g:5635:2: iv_ruleXReturnExpression= ruleXReturnExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXReturnExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXReturnExpression=ruleXReturnExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXReturnExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXReturnExpression"
+
+
+    // $ANTLR start "ruleXReturnExpression"
+    // InternalOXtype.g:5641:1: ruleXReturnExpression returns [EObject current=null] : ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) ;
+    public final EObject ruleXReturnExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        EObject lv_expression_2_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5647:2: ( ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? ) )
+            // InternalOXtype.g:5648:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? )
+            {
+            // InternalOXtype.g:5648:2: ( () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )? )
+            // InternalOXtype.g:5649:3: () otherlv_1= 'return' ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?
+            {
+            // InternalOXtype.g:5649:3: ()
+            // InternalOXtype.g:5650:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXReturnExpressionAccess().getXReturnExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,82,FOLLOW_73); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXReturnExpressionAccess().getReturnKeyword_1());
+              		
+            }
+            // InternalOXtype.g:5660:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?
+            int alt99=2;
+            alt99 = dfa99.predict(input);
+            switch (alt99) {
+                case 1 :
+                    // InternalOXtype.g:5661:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:5662:4: (lv_expression_2_0= ruleXExpression )
+                    // InternalOXtype.g:5663:5: lv_expression_2_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      					newCompositeNode(grammarAccess.getXReturnExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+                      				
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_expression_2_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					if (current==null) {
+                      						current = createModelElementForParent(grammarAccess.getXReturnExpressionRule());
+                      					}
+                      					set(
+                      						current,
+                      						"expression",
+                      						lv_expression_2_0,
+                      						"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      					afterParserOrEnumRuleCall();
+                      				
+                    }
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXReturnExpression"
+
+
+    // $ANTLR start "entryRuleXTryCatchFinallyExpression"
+    // InternalOXtype.g:5684:1: entryRuleXTryCatchFinallyExpression returns [EObject current=null] : iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF ;
+    public final EObject entryRuleXTryCatchFinallyExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXTryCatchFinallyExpression = null;
+
+
+        try {
+            // InternalOXtype.g:5684:67: (iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF )
+            // InternalOXtype.g:5685:2: iv_ruleXTryCatchFinallyExpression= ruleXTryCatchFinallyExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXTryCatchFinallyExpression=ruleXTryCatchFinallyExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXTryCatchFinallyExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXTryCatchFinallyExpression"
+
+
+    // $ANTLR start "ruleXTryCatchFinallyExpression"
+    // InternalOXtype.g:5691:1: ruleXTryCatchFinallyExpression returns [EObject current=null] : ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) ;
+    public final EObject ruleXTryCatchFinallyExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_4=null;
+        Token otherlv_6=null;
+        EObject lv_expression_2_0 = null;
+
+        EObject lv_catchClauses_3_0 = null;
+
+        EObject lv_finallyExpression_5_0 = null;
+
+        EObject lv_finallyExpression_7_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5697:2: ( ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) ) )
+            // InternalOXtype.g:5698:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) )
+            {
+            // InternalOXtype.g:5698:2: ( () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) ) )
+            // InternalOXtype.g:5699:3: () otherlv_1= 'try' ( (lv_expression_2_0= ruleXExpression ) ) ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) )
+            {
+            // InternalOXtype.g:5699:3: ()
+            // InternalOXtype.g:5700:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getXTryCatchFinallyExpressionAccess().getXTryCatchFinallyExpressionAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,83,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXTryCatchFinallyExpressionAccess().getTryKeyword_1());
+              		
+            }
+            // InternalOXtype.g:5710:3: ( (lv_expression_2_0= ruleXExpression ) )
+            // InternalOXtype.g:5711:4: (lv_expression_2_0= ruleXExpression )
+            {
+            // InternalOXtype.g:5711:4: (lv_expression_2_0= ruleXExpression )
+            // InternalOXtype.g:5712:5: lv_expression_2_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getExpressionXExpressionParserRuleCall_2_0());
+              				
+            }
+            pushFollow(FOLLOW_74);
+            lv_expression_2_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+              					}
+              					set(
+              						current,
+              						"expression",
+              						lv_expression_2_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:5729:3: ( ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? ) | (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) ) )
+            int alt102=2;
+            int LA102_0 = input.LA(1);
+
+            if ( (LA102_0==86) ) {
+                alt102=1;
+            }
+            else if ( (LA102_0==84) ) {
+                alt102=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 102, 0, input);
+
+                throw nvae;
+            }
+            switch (alt102) {
+                case 1 :
+                    // InternalOXtype.g:5730:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? )
+                    {
+                    // InternalOXtype.g:5730:4: ( ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )? )
+                    // InternalOXtype.g:5731:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+ ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )?
+                    {
+                    // InternalOXtype.g:5731:5: ( ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause ) )+
+                    int cnt100=0;
+                    loop100:
+                    do {
+                        int alt100=2;
+                        int LA100_0 = input.LA(1);
+
+                        if ( (LA100_0==86) ) {
+                            int LA100_2 = input.LA(2);
+
+                            if ( (synpred44_InternalOXtype()) ) {
+                                alt100=1;
+                            }
+
+
+                        }
+
+
+                        switch (alt100) {
+                    	case 1 :
+                    	    // InternalOXtype.g:5732:6: ( 'catch' )=> (lv_catchClauses_3_0= ruleXCatchClause )
+                    	    {
+                    	    // InternalOXtype.g:5733:6: (lv_catchClauses_3_0= ruleXCatchClause )
+                    	    // InternalOXtype.g:5734:7: lv_catchClauses_3_0= ruleXCatchClause
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getCatchClausesXCatchClauseParserRuleCall_3_0_0_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_75);
+                    	    lv_catchClauses_3_0=ruleXCatchClause();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"catchClauses",
+                    	      								lv_catchClauses_3_0,
+                    	      								"org.eclipse.xtext.xbase.Xbase.XCatchClause");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    if ( cnt100 >= 1 ) break loop100;
+                    	    if (state.backtracking>0) {state.failed=true; return current;}
+                                EarlyExitException eee =
+                                    new EarlyExitException(100, input);
+                                throw eee;
+                        }
+                        cnt100++;
+                    } while (true);
+
+                    // InternalOXtype.g:5751:5: ( ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) ) )?
+                    int alt101=2;
+                    int LA101_0 = input.LA(1);
+
+                    if ( (LA101_0==84) ) {
+                        int LA101_1 = input.LA(2);
+
+                        if ( (synpred45_InternalOXtype()) ) {
+                            alt101=1;
+                        }
+                    }
+                    switch (alt101) {
+                        case 1 :
+                            // InternalOXtype.g:5752:6: ( ( 'finally' )=>otherlv_4= 'finally' ) ( (lv_finallyExpression_5_0= ruleXExpression ) )
+                            {
+                            // InternalOXtype.g:5752:6: ( ( 'finally' )=>otherlv_4= 'finally' )
+                            // InternalOXtype.g:5753:7: ( 'finally' )=>otherlv_4= 'finally'
+                            {
+                            otherlv_4=(Token)match(input,84,FOLLOW_13); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							newLeafNode(otherlv_4, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_0_1_0());
+                              						
+                            }
+
+                            }
+
+                            // InternalOXtype.g:5759:6: ( (lv_finallyExpression_5_0= ruleXExpression ) )
+                            // InternalOXtype.g:5760:7: (lv_finallyExpression_5_0= ruleXExpression )
+                            {
+                            // InternalOXtype.g:5760:7: (lv_finallyExpression_5_0= ruleXExpression )
+                            // InternalOXtype.g:5761:8: lv_finallyExpression_5_0= ruleXExpression
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              								newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_0_1_1_0());
+                              							
+                            }
+                            pushFollow(FOLLOW_2);
+                            lv_finallyExpression_5_0=ruleXExpression();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              								if (current==null) {
+                              									current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+                              								}
+                              								set(
+                              									current,
+                              									"finallyExpression",
+                              									lv_finallyExpression_5_0,
+                              									"org.eclipse.xtext.xbase.Xbase.XExpression");
+                              								afterParserOrEnumRuleCall();
+                              							
+                            }
+
+                            }
+
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:5781:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) )
+                    {
+                    // InternalOXtype.g:5781:4: (otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) ) )
+                    // InternalOXtype.g:5782:5: otherlv_6= 'finally' ( (lv_finallyExpression_7_0= ruleXExpression ) )
+                    {
+                    otherlv_6=(Token)match(input,84,FOLLOW_13); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_6, grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyKeyword_3_1_0());
+                      				
+                    }
+                    // InternalOXtype.g:5786:5: ( (lv_finallyExpression_7_0= ruleXExpression ) )
+                    // InternalOXtype.g:5787:6: (lv_finallyExpression_7_0= ruleXExpression )
+                    {
+                    // InternalOXtype.g:5787:6: (lv_finallyExpression_7_0= ruleXExpression )
+                    // InternalOXtype.g:5788:7: lv_finallyExpression_7_0= ruleXExpression
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getXTryCatchFinallyExpressionAccess().getFinallyExpressionXExpressionParserRuleCall_3_1_1_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_2);
+                    lv_finallyExpression_7_0=ruleXExpression();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getXTryCatchFinallyExpressionRule());
+                      							}
+                      							set(
+                      								current,
+                      								"finallyExpression",
+                      								lv_finallyExpression_7_0,
+                      								"org.eclipse.xtext.xbase.Xbase.XExpression");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXTryCatchFinallyExpression"
+
+
+    // $ANTLR start "entryRuleXSynchronizedExpression"
+    // InternalOXtype.g:5811:1: entryRuleXSynchronizedExpression returns [EObject current=null] : iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF ;
+    public final EObject entryRuleXSynchronizedExpression() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXSynchronizedExpression = null;
+
+
+        try {
+            // InternalOXtype.g:5811:64: (iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF )
+            // InternalOXtype.g:5812:2: iv_ruleXSynchronizedExpression= ruleXSynchronizedExpression EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXSynchronizedExpressionRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXSynchronizedExpression=ruleXSynchronizedExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXSynchronizedExpression; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXSynchronizedExpression"
+
+
+    // $ANTLR start "ruleXSynchronizedExpression"
+    // InternalOXtype.g:5818:1: ruleXSynchronizedExpression returns [EObject current=null] : ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXSynchronizedExpression() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        EObject lv_param_3_0 = null;
+
+        EObject lv_expression_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5824:2: ( ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:5825:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:5825:2: ( ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) ) )
+            // InternalOXtype.g:5826:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) ) ( (lv_param_3_0= ruleXExpression ) ) otherlv_4= ')' ( (lv_expression_5_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:5826:3: ( ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' ) )
+            // InternalOXtype.g:5827:4: ( ( () 'synchronized' '(' ) )=> ( () otherlv_1= 'synchronized' otherlv_2= '(' )
+            {
+            // InternalOXtype.g:5834:4: ( () otherlv_1= 'synchronized' otherlv_2= '(' )
+            // InternalOXtype.g:5835:5: () otherlv_1= 'synchronized' otherlv_2= '('
+            {
+            // InternalOXtype.g:5835:5: ()
+            // InternalOXtype.g:5836:6: 
+            {
+            if ( state.backtracking==0 ) {
+
+              						current = forceCreateModelElement(
+              							grammarAccess.getXSynchronizedExpressionAccess().getXSynchronizedExpressionAction_0_0_0(),
+              							current);
+              					
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,85,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_1, grammarAccess.getXSynchronizedExpressionAccess().getSynchronizedKeyword_0_0_1());
+              				
+            }
+            otherlv_2=(Token)match(input,20,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					newLeafNode(otherlv_2, grammarAccess.getXSynchronizedExpressionAccess().getLeftParenthesisKeyword_0_0_2());
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:5852:3: ( (lv_param_3_0= ruleXExpression ) )
+            // InternalOXtype.g:5853:4: (lv_param_3_0= ruleXExpression )
+            {
+            // InternalOXtype.g:5853:4: (lv_param_3_0= ruleXExpression )
+            // InternalOXtype.g:5854:5: lv_param_3_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getParamXExpressionParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_11);
+            lv_param_3_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+              					}
+              					set(
+              						current,
+              						"param",
+              						lv_param_3_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_4=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_4, grammarAccess.getXSynchronizedExpressionAccess().getRightParenthesisKeyword_2());
+              		
+            }
+            // InternalOXtype.g:5875:3: ( (lv_expression_5_0= ruleXExpression ) )
+            // InternalOXtype.g:5876:4: (lv_expression_5_0= ruleXExpression )
+            {
+            // InternalOXtype.g:5876:4: (lv_expression_5_0= ruleXExpression )
+            // InternalOXtype.g:5877:5: lv_expression_5_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXSynchronizedExpressionAccess().getExpressionXExpressionParserRuleCall_3_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_expression_5_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXSynchronizedExpressionRule());
+              					}
+              					set(
+              						current,
+              						"expression",
+              						lv_expression_5_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXSynchronizedExpression"
+
+
+    // $ANTLR start "entryRuleXCatchClause"
+    // InternalOXtype.g:5898:1: entryRuleXCatchClause returns [EObject current=null] : iv_ruleXCatchClause= ruleXCatchClause EOF ;
+    public final EObject entryRuleXCatchClause() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXCatchClause = null;
+
+
+        try {
+            // InternalOXtype.g:5898:53: (iv_ruleXCatchClause= ruleXCatchClause EOF )
+            // InternalOXtype.g:5899:2: iv_ruleXCatchClause= ruleXCatchClause EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXCatchClauseRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXCatchClause=ruleXCatchClause();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXCatchClause; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXCatchClause"
+
+
+    // $ANTLR start "ruleXCatchClause"
+    // InternalOXtype.g:5905:1: ruleXCatchClause returns [EObject current=null] : ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) ;
+    public final EObject ruleXCatchClause() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        EObject lv_declaredParam_2_0 = null;
+
+        EObject lv_expression_4_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5911:2: ( ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) ) )
+            // InternalOXtype.g:5912:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) )
+            {
+            // InternalOXtype.g:5912:2: ( ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) ) )
+            // InternalOXtype.g:5913:3: ( ( 'catch' )=>otherlv_0= 'catch' ) otherlv_1= '(' ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) ) otherlv_3= ')' ( (lv_expression_4_0= ruleXExpression ) )
+            {
+            // InternalOXtype.g:5913:3: ( ( 'catch' )=>otherlv_0= 'catch' )
+            // InternalOXtype.g:5914:4: ( 'catch' )=>otherlv_0= 'catch'
+            {
+            otherlv_0=(Token)match(input,86,FOLLOW_52); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              				newLeafNode(otherlv_0, grammarAccess.getXCatchClauseAccess().getCatchKeyword_0());
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,20,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getXCatchClauseAccess().getLeftParenthesisKeyword_1());
+              		
+            }
+            // InternalOXtype.g:5924:3: ( (lv_declaredParam_2_0= ruleFullJvmFormalParameter ) )
+            // InternalOXtype.g:5925:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter )
+            {
+            // InternalOXtype.g:5925:4: (lv_declaredParam_2_0= ruleFullJvmFormalParameter )
+            // InternalOXtype.g:5926:5: lv_declaredParam_2_0= ruleFullJvmFormalParameter
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXCatchClauseAccess().getDeclaredParamFullJvmFormalParameterParserRuleCall_2_0());
+              				
+            }
+            pushFollow(FOLLOW_11);
+            lv_declaredParam_2_0=ruleFullJvmFormalParameter();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+              					}
+              					set(
+              						current,
+              						"declaredParam",
+              						lv_declaredParam_2_0,
+              						"org.eclipse.xtext.xbase.Xbase.FullJvmFormalParameter");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            otherlv_3=(Token)match(input,22,FOLLOW_13); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_3, grammarAccess.getXCatchClauseAccess().getRightParenthesisKeyword_3());
+              		
+            }
+            // InternalOXtype.g:5947:3: ( (lv_expression_4_0= ruleXExpression ) )
+            // InternalOXtype.g:5948:4: (lv_expression_4_0= ruleXExpression )
+            {
+            // InternalOXtype.g:5948:4: (lv_expression_4_0= ruleXExpression )
+            // InternalOXtype.g:5949:5: lv_expression_4_0= ruleXExpression
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXCatchClauseAccess().getExpressionXExpressionParserRuleCall_4_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_expression_4_0=ruleXExpression();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXCatchClauseRule());
+              					}
+              					set(
+              						current,
+              						"expression",
+              						lv_expression_4_0,
+              						"org.eclipse.xtext.xbase.Xbase.XExpression");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXCatchClause"
+
+
+    // $ANTLR start "entryRuleQualifiedName"
+    // InternalOXtype.g:5970:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ;
+    public final String entryRuleQualifiedName() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleQualifiedName = null;
+
+
+        try {
+            // InternalOXtype.g:5970:53: (iv_ruleQualifiedName= ruleQualifiedName EOF )
+            // InternalOXtype.g:5971:2: iv_ruleQualifiedName= ruleQualifiedName EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getQualifiedNameRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleQualifiedName=ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleQualifiedName.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleQualifiedName"
+
+
+    // $ANTLR start "ruleQualifiedName"
+    // InternalOXtype.g:5977:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) ;
+    public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+        AntlrDatatypeRuleToken this_ValidID_0 = null;
+
+        AntlrDatatypeRuleToken this_ValidID_2 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:5983:2: ( (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* ) )
+            // InternalOXtype.g:5984:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* )
+            {
+            // InternalOXtype.g:5984:2: (this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )* )
+            // InternalOXtype.g:5985:3: this_ValidID_0= ruleValidID ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )*
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_76);
+            this_ValidID_0=ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current.merge(this_ValidID_0);
+              		
+            }
+            if ( state.backtracking==0 ) {
+
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            // InternalOXtype.g:5995:3: ( ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID )*
+            loop103:
+            do {
+                int alt103=2;
+                int LA103_0 = input.LA(1);
+
+                if ( (LA103_0==57) ) {
+                    int LA103_2 = input.LA(2);
+
+                    if ( (LA103_2==RULE_ID) ) {
+                        int LA103_3 = input.LA(3);
+
+                        if ( (synpred48_InternalOXtype()) ) {
+                            alt103=1;
+                        }
+
+
+                    }
+
+
+                }
+
+
+                switch (alt103) {
+            	case 1 :
+            	    // InternalOXtype.g:5996:4: ( ( '.' )=>kw= '.' ) this_ValidID_2= ruleValidID
+            	    {
+            	    // InternalOXtype.g:5996:4: ( ( '.' )=>kw= '.' )
+            	    // InternalOXtype.g:5997:5: ( '.' )=>kw= '.'
+            	    {
+            	    kw=(Token)match(input,57,FOLLOW_7); if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      					current.merge(kw);
+            	      					newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0());
+            	      				
+            	    }
+
+            	    }
+
+            	    if ( state.backtracking==0 ) {
+
+            	      				newCompositeNode(grammarAccess.getQualifiedNameAccess().getValidIDParserRuleCall_1_1());
+            	      			
+            	    }
+            	    pushFollow(FOLLOW_76);
+            	    this_ValidID_2=ruleValidID();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      				current.merge(this_ValidID_2);
+            	      			
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      				afterParserOrEnumRuleCall();
+            	      			
+            	    }
+
+            	    }
+            	    break;
+
+            	default :
+            	    break loop103;
+                }
+            } while (true);
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleQualifiedName"
+
+
+    // $ANTLR start "entryRuleNumber"
+    // InternalOXtype.g:6019:1: entryRuleNumber returns [String current=null] : iv_ruleNumber= ruleNumber EOF ;
+    public final String entryRuleNumber() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleNumber = null;
+
+
+
+        	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+
+        try {
+            // InternalOXtype.g:6021:2: (iv_ruleNumber= ruleNumber EOF )
+            // InternalOXtype.g:6022:2: iv_ruleNumber= ruleNumber EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getNumberRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleNumber=ruleNumber();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleNumber.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+
+            	myHiddenTokenState.restore();
+
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleNumber"
+
+
+    // $ANTLR start "ruleNumber"
+    // InternalOXtype.g:6031:1: ruleNumber returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) ;
+    public final AntlrDatatypeRuleToken ruleNumber() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token this_HEX_0=null;
+        Token this_INT_1=null;
+        Token this_DECIMAL_2=null;
+        Token kw=null;
+        Token this_INT_4=null;
+        Token this_DECIMAL_5=null;
+
+
+        	enterRule();
+        	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
+
+        try {
+            // InternalOXtype.g:6038:2: ( (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) ) )
+            // InternalOXtype.g:6039:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) )
+            {
+            // InternalOXtype.g:6039:2: (this_HEX_0= RULE_HEX | ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? ) )
+            int alt107=2;
+            int LA107_0 = input.LA(1);
+
+            if ( (LA107_0==RULE_HEX) ) {
+                alt107=1;
+            }
+            else if ( ((LA107_0>=RULE_INT && LA107_0<=RULE_DECIMAL)) ) {
+                alt107=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 107, 0, input);
+
+                throw nvae;
+            }
+            switch (alt107) {
+                case 1 :
+                    // InternalOXtype.g:6040:3: this_HEX_0= RULE_HEX
+                    {
+                    this_HEX_0=(Token)match(input,RULE_HEX,FOLLOW_2); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current.merge(this_HEX_0);
+                      		
+                    }
+                    if ( state.backtracking==0 ) {
+
+                      			newLeafNode(this_HEX_0, grammarAccess.getNumberAccess().getHEXTerminalRuleCall_0());
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6048:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? )
+                    {
+                    // InternalOXtype.g:6048:3: ( (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )? )
+                    // InternalOXtype.g:6049:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL ) (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )?
+                    {
+                    // InternalOXtype.g:6049:4: (this_INT_1= RULE_INT | this_DECIMAL_2= RULE_DECIMAL )
+                    int alt104=2;
+                    int LA104_0 = input.LA(1);
+
+                    if ( (LA104_0==RULE_INT) ) {
+                        alt104=1;
+                    }
+                    else if ( (LA104_0==RULE_DECIMAL) ) {
+                        alt104=2;
+                    }
+                    else {
+                        if (state.backtracking>0) {state.failed=true; return current;}
+                        NoViableAltException nvae =
+                            new NoViableAltException("", 104, 0, input);
+
+                        throw nvae;
+                    }
+                    switch (alt104) {
+                        case 1 :
+                            // InternalOXtype.g:6050:5: this_INT_1= RULE_INT
+                            {
+                            this_INT_1=(Token)match(input,RULE_INT,FOLLOW_76); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(this_INT_1);
+                              				
+                            }
+                            if ( state.backtracking==0 ) {
+
+                              					newLeafNode(this_INT_1, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_0_0());
+                              				
+                            }
+
+                            }
+                            break;
+                        case 2 :
+                            // InternalOXtype.g:6058:5: this_DECIMAL_2= RULE_DECIMAL
+                            {
+                            this_DECIMAL_2=(Token)match(input,RULE_DECIMAL,FOLLOW_76); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(this_DECIMAL_2);
+                              				
+                            }
+                            if ( state.backtracking==0 ) {
+
+                              					newLeafNode(this_DECIMAL_2, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_0_1());
+                              				
+                            }
+
+                            }
+                            break;
+
+                    }
+
+                    // InternalOXtype.g:6066:4: (kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL ) )?
+                    int alt106=2;
+                    int LA106_0 = input.LA(1);
+
+                    if ( (LA106_0==57) ) {
+                        int LA106_1 = input.LA(2);
+
+                        if ( ((LA106_1>=RULE_INT && LA106_1<=RULE_DECIMAL)) ) {
+                            alt106=1;
+                        }
+                    }
+                    switch (alt106) {
+                        case 1 :
+                            // InternalOXtype.g:6067:5: kw= '.' (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL )
+                            {
+                            kw=(Token)match(input,57,FOLLOW_77); if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              					current.merge(kw);
+                              					newLeafNode(kw, grammarAccess.getNumberAccess().getFullStopKeyword_1_1_0());
+                              				
+                            }
+                            // InternalOXtype.g:6072:5: (this_INT_4= RULE_INT | this_DECIMAL_5= RULE_DECIMAL )
+                            int alt105=2;
+                            int LA105_0 = input.LA(1);
+
+                            if ( (LA105_0==RULE_INT) ) {
+                                alt105=1;
+                            }
+                            else if ( (LA105_0==RULE_DECIMAL) ) {
+                                alt105=2;
+                            }
+                            else {
+                                if (state.backtracking>0) {state.failed=true; return current;}
+                                NoViableAltException nvae =
+                                    new NoViableAltException("", 105, 0, input);
+
+                                throw nvae;
+                            }
+                            switch (alt105) {
+                                case 1 :
+                                    // InternalOXtype.g:6073:6: this_INT_4= RULE_INT
+                                    {
+                                    this_INT_4=(Token)match(input,RULE_INT,FOLLOW_2); if (state.failed) return current;
+                                    if ( state.backtracking==0 ) {
+
+                                      						current.merge(this_INT_4);
+                                      					
+                                    }
+                                    if ( state.backtracking==0 ) {
+
+                                      						newLeafNode(this_INT_4, grammarAccess.getNumberAccess().getINTTerminalRuleCall_1_1_1_0());
+                                      					
+                                    }
+
+                                    }
+                                    break;
+                                case 2 :
+                                    // InternalOXtype.g:6081:6: this_DECIMAL_5= RULE_DECIMAL
+                                    {
+                                    this_DECIMAL_5=(Token)match(input,RULE_DECIMAL,FOLLOW_2); if (state.failed) return current;
+                                    if ( state.backtracking==0 ) {
+
+                                      						current.merge(this_DECIMAL_5);
+                                      					
+                                    }
+                                    if ( state.backtracking==0 ) {
+
+                                      						newLeafNode(this_DECIMAL_5, grammarAccess.getNumberAccess().getDECIMALTerminalRuleCall_1_1_1_1());
+                                      					
+                                    }
+
+                                    }
+                                    break;
+
+                            }
+
+
+                            }
+                            break;
+
+                    }
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+
+            	myHiddenTokenState.restore();
+
+        }
+        return current;
+    }
+    // $ANTLR end "ruleNumber"
+
+
+    // $ANTLR start "entryRuleJvmTypeReference"
+    // InternalOXtype.g:6098:1: entryRuleJvmTypeReference returns [EObject current=null] : iv_ruleJvmTypeReference= ruleJvmTypeReference EOF ;
+    public final EObject entryRuleJvmTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmTypeReference = null;
+
+
+        try {
+            // InternalOXtype.g:6098:57: (iv_ruleJvmTypeReference= ruleJvmTypeReference EOF )
+            // InternalOXtype.g:6099:2: iv_ruleJvmTypeReference= ruleJvmTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmTypeReference=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmTypeReference; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmTypeReference"
+
+
+    // $ANTLR start "ruleJvmTypeReference"
+    // InternalOXtype.g:6105:1: ruleJvmTypeReference returns [EObject current=null] : ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) ;
+    public final EObject ruleJvmTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_JvmParameterizedTypeReference_0 = null;
+
+        EObject this_XFunctionTypeRef_3 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6111:2: ( ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef ) )
+            // InternalOXtype.g:6112:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef )
+            {
+            // InternalOXtype.g:6112:2: ( (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* ) | this_XFunctionTypeRef_3= ruleXFunctionTypeRef )
+            int alt109=2;
+            int LA109_0 = input.LA(1);
+
+            if ( (LA109_0==RULE_ID) ) {
+                alt109=1;
+            }
+            else if ( (LA109_0==20||LA109_0==45) ) {
+                alt109=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 109, 0, input);
+
+                throw nvae;
+            }
+            switch (alt109) {
+                case 1 :
+                    // InternalOXtype.g:6113:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* )
+                    {
+                    // InternalOXtype.g:6113:3: (this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )* )
+                    // InternalOXtype.g:6114:4: this_JvmParameterizedTypeReference_0= ruleJvmParameterizedTypeReference ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )*
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      				newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getJvmParameterizedTypeReferenceParserRuleCall_0_0());
+                      			
+                    }
+                    pushFollow(FOLLOW_70);
+                    this_JvmParameterizedTypeReference_0=ruleJvmParameterizedTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				current = this_JvmParameterizedTypeReference_0;
+                      				afterParserOrEnumRuleCall();
+                      			
+                    }
+                    // InternalOXtype.g:6122:4: ( ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets ) )*
+                    loop108:
+                    do {
+                        int alt108=2;
+                        int LA108_0 = input.LA(1);
+
+                        if ( (LA108_0==25) ) {
+                            int LA108_2 = input.LA(2);
+
+                            if ( (LA108_2==26) ) {
+                                int LA108_3 = input.LA(3);
+
+                                if ( (synpred49_InternalOXtype()) ) {
+                                    alt108=1;
+                                }
+
+
+                            }
+
+
+                        }
+
+
+                        switch (alt108) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6123:5: ( ( () ruleArrayBrackets ) )=> ( () ruleArrayBrackets )
+                    	    {
+                    	    // InternalOXtype.g:6129:5: ( () ruleArrayBrackets )
+                    	    // InternalOXtype.g:6130:6: () ruleArrayBrackets
+                    	    {
+                    	    // InternalOXtype.g:6130:6: ()
+                    	    // InternalOXtype.g:6131:7: 
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							current = forceCreateModelElementAndSet(
+                    	      								grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0(),
+                    	      								current);
+                    	      						
+                    	    }
+
+                    	    }
+
+                    	    if ( state.backtracking==0 ) {
+
+                    	      						newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getArrayBracketsParserRuleCall_0_1_0_1());
+                    	      					
+                    	    }
+                    	    pushFollow(FOLLOW_70);
+                    	    ruleArrayBrackets();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      						afterParserOrEnumRuleCall();
+                    	      					
+                    	    }
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop108;
+                        }
+                    } while (true);
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6148:3: this_XFunctionTypeRef_3= ruleXFunctionTypeRef
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getJvmTypeReferenceAccess().getXFunctionTypeRefParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_XFunctionTypeRef_3=ruleXFunctionTypeRef();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_XFunctionTypeRef_3;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmTypeReference"
+
+
+    // $ANTLR start "entryRuleArrayBrackets"
+    // InternalOXtype.g:6160:1: entryRuleArrayBrackets returns [String current=null] : iv_ruleArrayBrackets= ruleArrayBrackets EOF ;
+    public final String entryRuleArrayBrackets() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleArrayBrackets = null;
+
+
+        try {
+            // InternalOXtype.g:6160:53: (iv_ruleArrayBrackets= ruleArrayBrackets EOF )
+            // InternalOXtype.g:6161:2: iv_ruleArrayBrackets= ruleArrayBrackets EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getArrayBracketsRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleArrayBrackets=ruleArrayBrackets();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleArrayBrackets.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleArrayBrackets"
+
+
+    // $ANTLR start "ruleArrayBrackets"
+    // InternalOXtype.g:6167:1: ruleArrayBrackets returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (kw= '[' kw= ']' ) ;
+    public final AntlrDatatypeRuleToken ruleArrayBrackets() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6173:2: ( (kw= '[' kw= ']' ) )
+            // InternalOXtype.g:6174:2: (kw= '[' kw= ']' )
+            {
+            // InternalOXtype.g:6174:2: (kw= '[' kw= ']' )
+            // InternalOXtype.g:6175:3: kw= '[' kw= ']'
+            {
+            kw=(Token)match(input,25,FOLLOW_49); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current.merge(kw);
+              			newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getLeftSquareBracketKeyword_0());
+              		
+            }
+            kw=(Token)match(input,26,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current.merge(kw);
+              			newLeafNode(kw, grammarAccess.getArrayBracketsAccess().getRightSquareBracketKeyword_1());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleArrayBrackets"
+
+
+    // $ANTLR start "entryRuleXFunctionTypeRef"
+    // InternalOXtype.g:6189:1: entryRuleXFunctionTypeRef returns [EObject current=null] : iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF ;
+    public final EObject entryRuleXFunctionTypeRef() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleXFunctionTypeRef = null;
+
+
+        try {
+            // InternalOXtype.g:6189:57: (iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF )
+            // InternalOXtype.g:6190:2: iv_ruleXFunctionTypeRef= ruleXFunctionTypeRef EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getXFunctionTypeRefRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleXFunctionTypeRef=ruleXFunctionTypeRef();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleXFunctionTypeRef; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleXFunctionTypeRef"
+
+
+    // $ANTLR start "ruleXFunctionTypeRef"
+    // InternalOXtype.g:6196:1: ruleXFunctionTypeRef returns [EObject current=null] : ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) ;
+    public final EObject ruleXFunctionTypeRef() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        Token otherlv_2=null;
+        Token otherlv_4=null;
+        Token otherlv_5=null;
+        EObject lv_paramTypes_1_0 = null;
+
+        EObject lv_paramTypes_3_0 = null;
+
+        EObject lv_returnType_6_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6202:2: ( ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) ) )
+            // InternalOXtype.g:6203:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) )
+            {
+            // InternalOXtype.g:6203:2: ( (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) ) )
+            // InternalOXtype.g:6204:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )? otherlv_5= '=>' ( (lv_returnType_6_0= ruleJvmTypeReference ) )
+            {
+            // InternalOXtype.g:6204:3: (otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')' )?
+            int alt112=2;
+            int LA112_0 = input.LA(1);
+
+            if ( (LA112_0==20) ) {
+                alt112=1;
+            }
+            switch (alt112) {
+                case 1 :
+                    // InternalOXtype.g:6205:4: otherlv_0= '(' ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )? otherlv_4= ')'
+                    {
+                    otherlv_0=(Token)match(input,20,FOLLOW_78); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_0, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0());
+                      			
+                    }
+                    // InternalOXtype.g:6209:4: ( ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )* )?
+                    int alt111=2;
+                    int LA111_0 = input.LA(1);
+
+                    if ( (LA111_0==RULE_ID||LA111_0==20||LA111_0==45) ) {
+                        alt111=1;
+                    }
+                    switch (alt111) {
+                        case 1 :
+                            // InternalOXtype.g:6210:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) ) (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )*
+                            {
+                            // InternalOXtype.g:6210:5: ( (lv_paramTypes_1_0= ruleJvmTypeReference ) )
+                            // InternalOXtype.g:6211:6: (lv_paramTypes_1_0= ruleJvmTypeReference )
+                            {
+                            // InternalOXtype.g:6211:6: (lv_paramTypes_1_0= ruleJvmTypeReference )
+                            // InternalOXtype.g:6212:7: lv_paramTypes_1_0= ruleJvmTypeReference
+                            {
+                            if ( state.backtracking==0 ) {
+
+                              							newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_0_0());
+                              						
+                            }
+                            pushFollow(FOLLOW_10);
+                            lv_paramTypes_1_0=ruleJvmTypeReference();
+
+                            state._fsp--;
+                            if (state.failed) return current;
+                            if ( state.backtracking==0 ) {
+
+                              							if (current==null) {
+                              								current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+                              							}
+                              							add(
+                              								current,
+                              								"paramTypes",
+                              								lv_paramTypes_1_0,
+                              								"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+                              							afterParserOrEnumRuleCall();
+                              						
+                            }
+
+                            }
+
+
+                            }
+
+                            // InternalOXtype.g:6229:5: (otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) ) )*
+                            loop110:
+                            do {
+                                int alt110=2;
+                                int LA110_0 = input.LA(1);
+
+                                if ( (LA110_0==21) ) {
+                                    alt110=1;
+                                }
+
+
+                                switch (alt110) {
+                            	case 1 :
+                            	    // InternalOXtype.g:6230:6: otherlv_2= ',' ( (lv_paramTypes_3_0= ruleJvmTypeReference ) )
+                            	    {
+                            	    otherlv_2=(Token)match(input,21,FOLLOW_26); if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      						newLeafNode(otherlv_2, grammarAccess.getXFunctionTypeRefAccess().getCommaKeyword_0_1_1_0());
+                            	      					
+                            	    }
+                            	    // InternalOXtype.g:6234:6: ( (lv_paramTypes_3_0= ruleJvmTypeReference ) )
+                            	    // InternalOXtype.g:6235:7: (lv_paramTypes_3_0= ruleJvmTypeReference )
+                            	    {
+                            	    // InternalOXtype.g:6235:7: (lv_paramTypes_3_0= ruleJvmTypeReference )
+                            	    // InternalOXtype.g:6236:8: lv_paramTypes_3_0= ruleJvmTypeReference
+                            	    {
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getParamTypesJvmTypeReferenceParserRuleCall_0_1_1_1_0());
+                            	      							
+                            	    }
+                            	    pushFollow(FOLLOW_10);
+                            	    lv_paramTypes_3_0=ruleJvmTypeReference();
+
+                            	    state._fsp--;
+                            	    if (state.failed) return current;
+                            	    if ( state.backtracking==0 ) {
+
+                            	      								if (current==null) {
+                            	      									current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+                            	      								}
+                            	      								add(
+                            	      									current,
+                            	      									"paramTypes",
+                            	      									lv_paramTypes_3_0,
+                            	      									"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+                            	      								afterParserOrEnumRuleCall();
+                            	      							
+                            	    }
+
+                            	    }
+
+
+                            	    }
+
+
+                            	    }
+                            	    break;
+
+                            	default :
+                            	    break loop110;
+                                }
+                            } while (true);
+
+
+                            }
+                            break;
+
+                    }
+
+                    otherlv_4=(Token)match(input,22,FOLLOW_79); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_4, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2());
+                      			
+                    }
+
+                    }
+                    break;
+
+            }
+
+            otherlv_5=(Token)match(input,45,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_5, grammarAccess.getXFunctionTypeRefAccess().getEqualsSignGreaterThanSignKeyword_1());
+              		
+            }
+            // InternalOXtype.g:6264:3: ( (lv_returnType_6_0= ruleJvmTypeReference ) )
+            // InternalOXtype.g:6265:4: (lv_returnType_6_0= ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:6265:4: (lv_returnType_6_0= ruleJvmTypeReference )
+            // InternalOXtype.g:6266:5: lv_returnType_6_0= ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getXFunctionTypeRefAccess().getReturnTypeJvmTypeReferenceParserRuleCall_2_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_returnType_6_0=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getXFunctionTypeRefRule());
+              					}
+              					set(
+              						current,
+              						"returnType",
+              						lv_returnType_6_0,
+              						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleXFunctionTypeRef"
+
+
+    // $ANTLR start "entryRuleJvmParameterizedTypeReference"
+    // InternalOXtype.g:6287:1: entryRuleJvmParameterizedTypeReference returns [EObject current=null] : iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF ;
+    public final EObject entryRuleJvmParameterizedTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmParameterizedTypeReference = null;
+
+
+        try {
+            // InternalOXtype.g:6287:70: (iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF )
+            // InternalOXtype.g:6288:2: iv_ruleJvmParameterizedTypeReference= ruleJvmParameterizedTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmParameterizedTypeReference=ruleJvmParameterizedTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmParameterizedTypeReference; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmParameterizedTypeReference"
+
+
+    // $ANTLR start "ruleJvmParameterizedTypeReference"
+    // InternalOXtype.g:6294:1: ruleJvmParameterizedTypeReference returns [EObject current=null] : ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) ;
+    public final EObject ruleJvmParameterizedTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        Token otherlv_3=null;
+        Token otherlv_5=null;
+        Token otherlv_7=null;
+        Token otherlv_9=null;
+        Token otherlv_11=null;
+        Token otherlv_13=null;
+        EObject lv_arguments_2_0 = null;
+
+        EObject lv_arguments_4_0 = null;
+
+        EObject lv_arguments_10_0 = null;
+
+        EObject lv_arguments_12_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6300:2: ( ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? ) )
+            // InternalOXtype.g:6301:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? )
+            {
+            // InternalOXtype.g:6301:2: ( ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )? )
+            // InternalOXtype.g:6302:3: ( ( ruleQualifiedName ) ) ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?
+            {
+            // InternalOXtype.g:6302:3: ( ( ruleQualifiedName ) )
+            // InternalOXtype.g:6303:4: ( ruleQualifiedName )
+            {
+            // InternalOXtype.g:6303:4: ( ruleQualifiedName )
+            // InternalOXtype.g:6304:5: ruleQualifiedName
+            {
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+              					}
+              				
+            }
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_0_0());
+              				
+            }
+            pushFollow(FOLLOW_80);
+            ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+            // InternalOXtype.g:6318:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?
+            int alt117=2;
+            alt117 = dfa117.predict(input);
+            switch (alt117) {
+                case 1 :
+                    // InternalOXtype.g:6319:4: ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )*
+                    {
+                    // InternalOXtype.g:6319:4: ( ( '<' )=>otherlv_1= '<' )
+                    // InternalOXtype.g:6320:5: ( '<' )=>otherlv_1= '<'
+                    {
+                    otherlv_1=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      					newLeafNode(otherlv_1, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_0());
+                      				
+                    }
+
+                    }
+
+                    // InternalOXtype.g:6326:4: ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) )
+                    // InternalOXtype.g:6327:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference )
+                    {
+                    // InternalOXtype.g:6327:5: (lv_arguments_2_0= ruleJvmArgumentTypeReference )
+                    // InternalOXtype.g:6328:6: lv_arguments_2_0= ruleJvmArgumentTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      						newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_1_0());
+                      					
+                    }
+                    pushFollow(FOLLOW_39);
+                    lv_arguments_2_0=ruleJvmArgumentTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      						if (current==null) {
+                      							current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+                      						}
+                      						add(
+                      							current,
+                      							"arguments",
+                      							lv_arguments_2_0,
+                      							"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                      						afterParserOrEnumRuleCall();
+                      					
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:6345:4: (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )*
+                    loop113:
+                    do {
+                        int alt113=2;
+                        int LA113_0 = input.LA(1);
+
+                        if ( (LA113_0==21) ) {
+                            alt113=1;
+                        }
+
+
+                        switch (alt113) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6346:5: otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) )
+                    	    {
+                    	    otherlv_3=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      					newLeafNode(otherlv_3, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_2_0());
+                    	      				
+                    	    }
+                    	    // InternalOXtype.g:6350:5: ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) )
+                    	    // InternalOXtype.g:6351:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference )
+                    	    {
+                    	    // InternalOXtype.g:6351:6: (lv_arguments_4_0= ruleJvmArgumentTypeReference )
+                    	    // InternalOXtype.g:6352:7: lv_arguments_4_0= ruleJvmArgumentTypeReference
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_2_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_39);
+                    	    lv_arguments_4_0=ruleJvmArgumentTypeReference();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"arguments",
+                    	      								lv_arguments_4_0,
+                    	      								"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop113;
+                        }
+                    } while (true);
+
+                    otherlv_5=(Token)match(input,33,FOLLOW_76); if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      				newLeafNode(otherlv_5, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_3());
+                      			
+                    }
+                    // InternalOXtype.g:6374:4: ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )*
+                    loop116:
+                    do {
+                        int alt116=2;
+                        int LA116_0 = input.LA(1);
+
+                        if ( (LA116_0==57) ) {
+                            int LA116_2 = input.LA(2);
+
+                            if ( (LA116_2==RULE_ID) ) {
+                                int LA116_3 = input.LA(3);
+
+                                if ( (synpred51_InternalOXtype()) ) {
+                                    alt116=1;
+                                }
+
+
+                            }
+
+
+                        }
+
+
+                        switch (alt116) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6375:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?
+                    	    {
+                    	    // InternalOXtype.g:6375:5: ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) )
+                    	    // InternalOXtype.g:6376:6: ( ( () '.' ) )=> ( () otherlv_7= '.' )
+                    	    {
+                    	    // InternalOXtype.g:6382:6: ( () otherlv_7= '.' )
+                    	    // InternalOXtype.g:6383:7: () otherlv_7= '.'
+                    	    {
+                    	    // InternalOXtype.g:6383:7: ()
+                    	    // InternalOXtype.g:6384:8: 
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      								current = forceCreateModelElementAndSet(
+                    	      									grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0(),
+                    	      									current);
+                    	      							
+                    	    }
+
+                    	    }
+
+                    	    otherlv_7=(Token)match(input,57,FOLLOW_7); if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newLeafNode(otherlv_7, grammarAccess.getJvmParameterizedTypeReferenceAccess().getFullStopKeyword_1_4_0_0_1());
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+                    	    // InternalOXtype.g:6396:5: ( ( ruleValidID ) )
+                    	    // InternalOXtype.g:6397:6: ( ruleValidID )
+                    	    {
+                    	    // InternalOXtype.g:6397:6: ( ruleValidID )
+                    	    // InternalOXtype.g:6398:7: ruleValidID
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElement(grammarAccess.getJvmParameterizedTypeReferenceRule());
+                    	      							}
+                    	      						
+                    	    }
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getTypeJvmTypeCrossReference_1_4_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_81);
+                    	    ruleValidID();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+
+                    	    // InternalOXtype.g:6412:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?
+                    	    int alt115=2;
+                    	    alt115 = dfa115.predict(input);
+                    	    switch (alt115) {
+                    	        case 1 :
+                    	            // InternalOXtype.g:6413:6: ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>'
+                    	            {
+                    	            // InternalOXtype.g:6413:6: ( ( '<' )=>otherlv_9= '<' )
+                    	            // InternalOXtype.g:6414:7: ( '<' )=>otherlv_9= '<'
+                    	            {
+                    	            otherlv_9=(Token)match(input,32,FOLLOW_38); if (state.failed) return current;
+                    	            if ( state.backtracking==0 ) {
+
+                    	              							newLeafNode(otherlv_9, grammarAccess.getJvmParameterizedTypeReferenceAccess().getLessThanSignKeyword_1_4_2_0());
+                    	              						
+                    	            }
+
+                    	            }
+
+                    	            // InternalOXtype.g:6420:6: ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) )
+                    	            // InternalOXtype.g:6421:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference )
+                    	            {
+                    	            // InternalOXtype.g:6421:7: (lv_arguments_10_0= ruleJvmArgumentTypeReference )
+                    	            // InternalOXtype.g:6422:8: lv_arguments_10_0= ruleJvmArgumentTypeReference
+                    	            {
+                    	            if ( state.backtracking==0 ) {
+
+                    	              								newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_1_0());
+                    	              							
+                    	            }
+                    	            pushFollow(FOLLOW_39);
+                    	            lv_arguments_10_0=ruleJvmArgumentTypeReference();
+
+                    	            state._fsp--;
+                    	            if (state.failed) return current;
+                    	            if ( state.backtracking==0 ) {
+
+                    	              								if (current==null) {
+                    	              									current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+                    	              								}
+                    	              								add(
+                    	              									current,
+                    	              									"arguments",
+                    	              									lv_arguments_10_0,
+                    	              									"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                    	              								afterParserOrEnumRuleCall();
+                    	              							
+                    	            }
+
+                    	            }
+
+
+                    	            }
+
+                    	            // InternalOXtype.g:6439:6: (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )*
+                    	            loop114:
+                    	            do {
+                    	                int alt114=2;
+                    	                int LA114_0 = input.LA(1);
+
+                    	                if ( (LA114_0==21) ) {
+                    	                    alt114=1;
+                    	                }
+
+
+                    	                switch (alt114) {
+                    	            	case 1 :
+                    	            	    // InternalOXtype.g:6440:7: otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) )
+                    	            	    {
+                    	            	    otherlv_11=(Token)match(input,21,FOLLOW_38); if (state.failed) return current;
+                    	            	    if ( state.backtracking==0 ) {
+
+                    	            	      							newLeafNode(otherlv_11, grammarAccess.getJvmParameterizedTypeReferenceAccess().getCommaKeyword_1_4_2_2_0());
+                    	            	      						
+                    	            	    }
+                    	            	    // InternalOXtype.g:6444:7: ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) )
+                    	            	    // InternalOXtype.g:6445:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference )
+                    	            	    {
+                    	            	    // InternalOXtype.g:6445:8: (lv_arguments_12_0= ruleJvmArgumentTypeReference )
+                    	            	    // InternalOXtype.g:6446:9: lv_arguments_12_0= ruleJvmArgumentTypeReference
+                    	            	    {
+                    	            	    if ( state.backtracking==0 ) {
+
+                    	            	      									newCompositeNode(grammarAccess.getJvmParameterizedTypeReferenceAccess().getArgumentsJvmArgumentTypeReferenceParserRuleCall_1_4_2_2_1_0());
+                    	            	      								
+                    	            	    }
+                    	            	    pushFollow(FOLLOW_39);
+                    	            	    lv_arguments_12_0=ruleJvmArgumentTypeReference();
+
+                    	            	    state._fsp--;
+                    	            	    if (state.failed) return current;
+                    	            	    if ( state.backtracking==0 ) {
+
+                    	            	      									if (current==null) {
+                    	            	      										current = createModelElementForParent(grammarAccess.getJvmParameterizedTypeReferenceRule());
+                    	            	      									}
+                    	            	      									add(
+                    	            	      										current,
+                    	            	      										"arguments",
+                    	            	      										lv_arguments_12_0,
+                    	            	      										"org.eclipse.xtext.xbase.Xtype.JvmArgumentTypeReference");
+                    	            	      									afterParserOrEnumRuleCall();
+                    	            	      								
+                    	            	    }
+
+                    	            	    }
+
+
+                    	            	    }
+
+
+                    	            	    }
+                    	            	    break;
+
+                    	            	default :
+                    	            	    break loop114;
+                    	                }
+                    	            } while (true);
+
+                    	            otherlv_13=(Token)match(input,33,FOLLOW_76); if (state.failed) return current;
+                    	            if ( state.backtracking==0 ) {
+
+                    	              						newLeafNode(otherlv_13, grammarAccess.getJvmParameterizedTypeReferenceAccess().getGreaterThanSignKeyword_1_4_2_3());
+                    	              					
+                    	            }
+
+                    	            }
+                    	            break;
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop116;
+                        }
+                    } while (true);
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmParameterizedTypeReference"
+
+
+    // $ANTLR start "entryRuleJvmArgumentTypeReference"
+    // InternalOXtype.g:6475:1: entryRuleJvmArgumentTypeReference returns [EObject current=null] : iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF ;
+    public final EObject entryRuleJvmArgumentTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmArgumentTypeReference = null;
+
+
+        try {
+            // InternalOXtype.g:6475:65: (iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF )
+            // InternalOXtype.g:6476:2: iv_ruleJvmArgumentTypeReference= ruleJvmArgumentTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmArgumentTypeReference=ruleJvmArgumentTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmArgumentTypeReference; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmArgumentTypeReference"
+
+
+    // $ANTLR start "ruleJvmArgumentTypeReference"
+    // InternalOXtype.g:6482:1: ruleJvmArgumentTypeReference returns [EObject current=null] : (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) ;
+    public final EObject ruleJvmArgumentTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        EObject this_JvmTypeReference_0 = null;
+
+        EObject this_JvmWildcardTypeReference_1 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6488:2: ( (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference ) )
+            // InternalOXtype.g:6489:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference )
+            {
+            // InternalOXtype.g:6489:2: (this_JvmTypeReference_0= ruleJvmTypeReference | this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference )
+            int alt118=2;
+            int LA118_0 = input.LA(1);
+
+            if ( (LA118_0==RULE_ID||LA118_0==20||LA118_0==45) ) {
+                alt118=1;
+            }
+            else if ( (LA118_0==87) ) {
+                alt118=2;
+            }
+            else {
+                if (state.backtracking>0) {state.failed=true; return current;}
+                NoViableAltException nvae =
+                    new NoViableAltException("", 118, 0, input);
+
+                throw nvae;
+            }
+            switch (alt118) {
+                case 1 :
+                    // InternalOXtype.g:6490:3: this_JvmTypeReference_0= ruleJvmTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmTypeReferenceParserRuleCall_0());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_JvmTypeReference_0=ruleJvmTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_JvmTypeReference_0;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6499:3: this_JvmWildcardTypeReference_1= ruleJvmWildcardTypeReference
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      			newCompositeNode(grammarAccess.getJvmArgumentTypeReferenceAccess().getJvmWildcardTypeReferenceParserRuleCall_1());
+                      		
+                    }
+                    pushFollow(FOLLOW_2);
+                    this_JvmWildcardTypeReference_1=ruleJvmWildcardTypeReference();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      			current = this_JvmWildcardTypeReference_1;
+                      			afterParserOrEnumRuleCall();
+                      		
+                    }
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmArgumentTypeReference"
+
+
+    // $ANTLR start "entryRuleJvmWildcardTypeReference"
+    // InternalOXtype.g:6511:1: entryRuleJvmWildcardTypeReference returns [EObject current=null] : iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF ;
+    public final EObject entryRuleJvmWildcardTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmWildcardTypeReference = null;
+
+
+        try {
+            // InternalOXtype.g:6511:65: (iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF )
+            // InternalOXtype.g:6512:2: iv_ruleJvmWildcardTypeReference= ruleJvmWildcardTypeReference EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmWildcardTypeReference=ruleJvmWildcardTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmWildcardTypeReference; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmWildcardTypeReference"
+
+
+    // $ANTLR start "ruleJvmWildcardTypeReference"
+    // InternalOXtype.g:6518:1: ruleJvmWildcardTypeReference returns [EObject current=null] : ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) ;
+    public final EObject ruleJvmWildcardTypeReference() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_1=null;
+        EObject lv_constraints_2_0 = null;
+
+        EObject lv_constraints_3_0 = null;
+
+        EObject lv_constraints_4_0 = null;
+
+        EObject lv_constraints_5_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6524:2: ( ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? ) )
+            // InternalOXtype.g:6525:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? )
+            {
+            // InternalOXtype.g:6525:2: ( () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )? )
+            // InternalOXtype.g:6526:3: () otherlv_1= '?' ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )?
+            {
+            // InternalOXtype.g:6526:3: ()
+            // InternalOXtype.g:6527:4: 
+            {
+            if ( state.backtracking==0 ) {
+
+              				current = forceCreateModelElement(
+              					grammarAccess.getJvmWildcardTypeReferenceAccess().getJvmWildcardTypeReferenceAction_0(),
+              					current);
+              			
+            }
+
+            }
+
+            otherlv_1=(Token)match(input,87,FOLLOW_82); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_1, grammarAccess.getJvmWildcardTypeReferenceAccess().getQuestionMarkKeyword_1());
+              		
+            }
+            // InternalOXtype.g:6537:3: ( ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* ) | ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* ) )?
+            int alt121=3;
+            int LA121_0 = input.LA(1);
+
+            if ( (LA121_0==74) ) {
+                alt121=1;
+            }
+            else if ( (LA121_0==75) ) {
+                alt121=2;
+            }
+            switch (alt121) {
+                case 1 :
+                    // InternalOXtype.g:6538:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* )
+                    {
+                    // InternalOXtype.g:6538:4: ( ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )* )
+                    // InternalOXtype.g:6539:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) ) ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )*
+                    {
+                    // InternalOXtype.g:6539:5: ( (lv_constraints_2_0= ruleJvmUpperBound ) )
+                    // InternalOXtype.g:6540:6: (lv_constraints_2_0= ruleJvmUpperBound )
+                    {
+                    // InternalOXtype.g:6540:6: (lv_constraints_2_0= ruleJvmUpperBound )
+                    // InternalOXtype.g:6541:7: lv_constraints_2_0= ruleJvmUpperBound
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundParserRuleCall_2_0_0_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_83);
+                    lv_constraints_2_0=ruleJvmUpperBound();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+                      							}
+                      							add(
+                      								current,
+                      								"constraints",
+                      								lv_constraints_2_0,
+                      								"org.eclipse.xtext.xbase.Xtype.JvmUpperBound");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:6558:5: ( (lv_constraints_3_0= ruleJvmUpperBoundAnded ) )*
+                    loop119:
+                    do {
+                        int alt119=2;
+                        int LA119_0 = input.LA(1);
+
+                        if ( (LA119_0==88) ) {
+                            alt119=1;
+                        }
+
+
+                        switch (alt119) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6559:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded )
+                    	    {
+                    	    // InternalOXtype.g:6559:6: (lv_constraints_3_0= ruleJvmUpperBoundAnded )
+                    	    // InternalOXtype.g:6560:7: lv_constraints_3_0= ruleJvmUpperBoundAnded
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmUpperBoundAndedParserRuleCall_2_0_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_83);
+                    	    lv_constraints_3_0=ruleJvmUpperBoundAnded();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"constraints",
+                    	      								lv_constraints_3_0,
+                    	      								"org.eclipse.xtext.xbase.Xtype.JvmUpperBoundAnded");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop119;
+                        }
+                    } while (true);
+
+
+                    }
+
+
+                    }
+                    break;
+                case 2 :
+                    // InternalOXtype.g:6579:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* )
+                    {
+                    // InternalOXtype.g:6579:4: ( ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )* )
+                    // InternalOXtype.g:6580:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) ) ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )*
+                    {
+                    // InternalOXtype.g:6580:5: ( (lv_constraints_4_0= ruleJvmLowerBound ) )
+                    // InternalOXtype.g:6581:6: (lv_constraints_4_0= ruleJvmLowerBound )
+                    {
+                    // InternalOXtype.g:6581:6: (lv_constraints_4_0= ruleJvmLowerBound )
+                    // InternalOXtype.g:6582:7: lv_constraints_4_0= ruleJvmLowerBound
+                    {
+                    if ( state.backtracking==0 ) {
+
+                      							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundParserRuleCall_2_1_0_0());
+                      						
+                    }
+                    pushFollow(FOLLOW_83);
+                    lv_constraints_4_0=ruleJvmLowerBound();
+
+                    state._fsp--;
+                    if (state.failed) return current;
+                    if ( state.backtracking==0 ) {
+
+                      							if (current==null) {
+                      								current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+                      							}
+                      							add(
+                      								current,
+                      								"constraints",
+                      								lv_constraints_4_0,
+                      								"org.eclipse.xtext.xbase.Xtype.JvmLowerBound");
+                      							afterParserOrEnumRuleCall();
+                      						
+                    }
+
+                    }
+
+
+                    }
+
+                    // InternalOXtype.g:6599:5: ( (lv_constraints_5_0= ruleJvmLowerBoundAnded ) )*
+                    loop120:
+                    do {
+                        int alt120=2;
+                        int LA120_0 = input.LA(1);
+
+                        if ( (LA120_0==88) ) {
+                            alt120=1;
+                        }
+
+
+                        switch (alt120) {
+                    	case 1 :
+                    	    // InternalOXtype.g:6600:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded )
+                    	    {
+                    	    // InternalOXtype.g:6600:6: (lv_constraints_5_0= ruleJvmLowerBoundAnded )
+                    	    // InternalOXtype.g:6601:7: lv_constraints_5_0= ruleJvmLowerBoundAnded
+                    	    {
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							newCompositeNode(grammarAccess.getJvmWildcardTypeReferenceAccess().getConstraintsJvmLowerBoundAndedParserRuleCall_2_1_1_0());
+                    	      						
+                    	    }
+                    	    pushFollow(FOLLOW_83);
+                    	    lv_constraints_5_0=ruleJvmLowerBoundAnded();
+
+                    	    state._fsp--;
+                    	    if (state.failed) return current;
+                    	    if ( state.backtracking==0 ) {
+
+                    	      							if (current==null) {
+                    	      								current = createModelElementForParent(grammarAccess.getJvmWildcardTypeReferenceRule());
+                    	      							}
+                    	      							add(
+                    	      								current,
+                    	      								"constraints",
+                    	      								lv_constraints_5_0,
+                    	      								"org.eclipse.xtext.xbase.Xtype.JvmLowerBoundAnded");
+                    	      							afterParserOrEnumRuleCall();
+                    	      						
+                    	    }
+
+                    	    }
+
+
+                    	    }
+                    	    break;
+
+                    	default :
+                    	    break loop120;
+                        }
+                    } while (true);
+
+
+                    }
+
+
+                    }
+                    break;
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmWildcardTypeReference"
+
+
+    // $ANTLR start "entryRuleJvmUpperBound"
+    // InternalOXtype.g:6624:1: entryRuleJvmUpperBound returns [EObject current=null] : iv_ruleJvmUpperBound= ruleJvmUpperBound EOF ;
+    public final EObject entryRuleJvmUpperBound() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmUpperBound = null;
+
+
+        try {
+            // InternalOXtype.g:6624:54: (iv_ruleJvmUpperBound= ruleJvmUpperBound EOF )
+            // InternalOXtype.g:6625:2: iv_ruleJvmUpperBound= ruleJvmUpperBound EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmUpperBoundRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmUpperBound=ruleJvmUpperBound();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmUpperBound; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmUpperBound"
+
+
+    // $ANTLR start "ruleJvmUpperBound"
+    // InternalOXtype.g:6631:1: ruleJvmUpperBound returns [EObject current=null] : (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+    public final EObject ruleJvmUpperBound() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        EObject lv_typeReference_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6637:2: ( (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+            // InternalOXtype.g:6638:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            {
+            // InternalOXtype.g:6638:2: (otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            // InternalOXtype.g:6639:3: otherlv_0= 'extends' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            {
+            otherlv_0=(Token)match(input,74,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAccess().getExtendsKeyword_0());
+              		
+            }
+            // InternalOXtype.g:6643:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            // InternalOXtype.g:6644:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:6644:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            // InternalOXtype.g:6645:5: lv_typeReference_1_0= ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getJvmUpperBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_typeReference_1_0=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getJvmUpperBoundRule());
+              					}
+              					set(
+              						current,
+              						"typeReference",
+              						lv_typeReference_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmUpperBound"
+
+
+    // $ANTLR start "entryRuleJvmUpperBoundAnded"
+    // InternalOXtype.g:6666:1: entryRuleJvmUpperBoundAnded returns [EObject current=null] : iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF ;
+    public final EObject entryRuleJvmUpperBoundAnded() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmUpperBoundAnded = null;
+
+
+        try {
+            // InternalOXtype.g:6666:59: (iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF )
+            // InternalOXtype.g:6667:2: iv_ruleJvmUpperBoundAnded= ruleJvmUpperBoundAnded EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmUpperBoundAndedRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmUpperBoundAnded=ruleJvmUpperBoundAnded();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmUpperBoundAnded; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmUpperBoundAnded"
+
+
+    // $ANTLR start "ruleJvmUpperBoundAnded"
+    // InternalOXtype.g:6673:1: ruleJvmUpperBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+    public final EObject ruleJvmUpperBoundAnded() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        EObject lv_typeReference_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6679:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+            // InternalOXtype.g:6680:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            {
+            // InternalOXtype.g:6680:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            // InternalOXtype.g:6681:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            {
+            otherlv_0=(Token)match(input,88,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_0, grammarAccess.getJvmUpperBoundAndedAccess().getAmpersandKeyword_0());
+              		
+            }
+            // InternalOXtype.g:6685:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            // InternalOXtype.g:6686:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:6686:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            // InternalOXtype.g:6687:5: lv_typeReference_1_0= ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getJvmUpperBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_typeReference_1_0=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getJvmUpperBoundAndedRule());
+              					}
+              					set(
+              						current,
+              						"typeReference",
+              						lv_typeReference_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmUpperBoundAnded"
+
+
+    // $ANTLR start "entryRuleJvmLowerBound"
+    // InternalOXtype.g:6708:1: entryRuleJvmLowerBound returns [EObject current=null] : iv_ruleJvmLowerBound= ruleJvmLowerBound EOF ;
+    public final EObject entryRuleJvmLowerBound() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmLowerBound = null;
+
+
+        try {
+            // InternalOXtype.g:6708:54: (iv_ruleJvmLowerBound= ruleJvmLowerBound EOF )
+            // InternalOXtype.g:6709:2: iv_ruleJvmLowerBound= ruleJvmLowerBound EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmLowerBoundRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmLowerBound=ruleJvmLowerBound();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmLowerBound; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmLowerBound"
+
+
+    // $ANTLR start "ruleJvmLowerBound"
+    // InternalOXtype.g:6715:1: ruleJvmLowerBound returns [EObject current=null] : (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+    public final EObject ruleJvmLowerBound() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        EObject lv_typeReference_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6721:2: ( (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+            // InternalOXtype.g:6722:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            {
+            // InternalOXtype.g:6722:2: (otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            // InternalOXtype.g:6723:3: otherlv_0= 'super' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            {
+            otherlv_0=(Token)match(input,75,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAccess().getSuperKeyword_0());
+              		
+            }
+            // InternalOXtype.g:6727:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            // InternalOXtype.g:6728:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:6728:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            // InternalOXtype.g:6729:5: lv_typeReference_1_0= ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getJvmLowerBoundAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_typeReference_1_0=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getJvmLowerBoundRule());
+              					}
+              					set(
+              						current,
+              						"typeReference",
+              						lv_typeReference_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmLowerBound"
+
+
+    // $ANTLR start "entryRuleJvmLowerBoundAnded"
+    // InternalOXtype.g:6750:1: entryRuleJvmLowerBoundAnded returns [EObject current=null] : iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF ;
+    public final EObject entryRuleJvmLowerBoundAnded() throws RecognitionException {
+        EObject current = null;
+
+        EObject iv_ruleJvmLowerBoundAnded = null;
+
+
+        try {
+            // InternalOXtype.g:6750:59: (iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF )
+            // InternalOXtype.g:6751:2: iv_ruleJvmLowerBoundAnded= ruleJvmLowerBoundAnded EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getJvmLowerBoundAndedRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleJvmLowerBoundAnded=ruleJvmLowerBoundAnded();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleJvmLowerBoundAnded; 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleJvmLowerBoundAnded"
+
+
+    // $ANTLR start "ruleJvmLowerBoundAnded"
+    // InternalOXtype.g:6757:1: ruleJvmLowerBoundAnded returns [EObject current=null] : (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) ;
+    public final EObject ruleJvmLowerBoundAnded() throws RecognitionException {
+        EObject current = null;
+
+        Token otherlv_0=null;
+        EObject lv_typeReference_1_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6763:2: ( (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) ) )
+            // InternalOXtype.g:6764:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            {
+            // InternalOXtype.g:6764:2: (otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) ) )
+            // InternalOXtype.g:6765:3: otherlv_0= '&' ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            {
+            otherlv_0=(Token)match(input,88,FOLLOW_26); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			newLeafNode(otherlv_0, grammarAccess.getJvmLowerBoundAndedAccess().getAmpersandKeyword_0());
+              		
+            }
+            // InternalOXtype.g:6769:3: ( (lv_typeReference_1_0= ruleJvmTypeReference ) )
+            // InternalOXtype.g:6770:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            {
+            // InternalOXtype.g:6770:4: (lv_typeReference_1_0= ruleJvmTypeReference )
+            // InternalOXtype.g:6771:5: lv_typeReference_1_0= ruleJvmTypeReference
+            {
+            if ( state.backtracking==0 ) {
+
+              					newCompositeNode(grammarAccess.getJvmLowerBoundAndedAccess().getTypeReferenceJvmTypeReferenceParserRuleCall_1_0());
+              				
+            }
+            pushFollow(FOLLOW_2);
+            lv_typeReference_1_0=ruleJvmTypeReference();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              					if (current==null) {
+              						current = createModelElementForParent(grammarAccess.getJvmLowerBoundAndedRule());
+              					}
+              					set(
+              						current,
+              						"typeReference",
+              						lv_typeReference_1_0,
+              						"org.eclipse.xtext.xbase.Xtype.JvmTypeReference");
+              					afterParserOrEnumRuleCall();
+              				
+            }
+
+            }
+
+
+            }
+
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleJvmLowerBoundAnded"
+
+
+    // $ANTLR start "entryRuleQualifiedNameWithWildcard"
+    // InternalOXtype.g:6792:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ;
+    public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null;
+
+
+        try {
+            // InternalOXtype.g:6792:65: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF )
+            // InternalOXtype.g:6793:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleQualifiedNameWithWildcard.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleQualifiedNameWithWildcard"
+
+
+    // $ANTLR start "ruleQualifiedNameWithWildcard"
+    // InternalOXtype.g:6799:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) ;
+    public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+        AntlrDatatypeRuleToken this_QualifiedName_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6805:2: ( (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' ) )
+            // InternalOXtype.g:6806:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' )
+            {
+            // InternalOXtype.g:6806:2: (this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*' )
+            // InternalOXtype.g:6807:3: this_QualifiedName_0= ruleQualifiedName kw= '.' kw= '*'
+            {
+            if ( state.backtracking==0 ) {
+
+              			newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0());
+              		
+            }
+            pushFollow(FOLLOW_84);
+            this_QualifiedName_0=ruleQualifiedName();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current.merge(this_QualifiedName_0);
+              		
+            }
+            if ( state.backtracking==0 ) {
+
+              			afterParserOrEnumRuleCall();
+              		
+            }
+            kw=(Token)match(input,57,FOLLOW_85); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current.merge(kw);
+              			newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopKeyword_1());
+              		
+            }
+            kw=(Token)match(input,16,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              			current.merge(kw);
+              			newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getAsteriskKeyword_2());
+              		
+            }
+
+            }
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleQualifiedNameWithWildcard"
+
+
+    // $ANTLR start "entryRuleValidID"
+    // InternalOXtype.g:6831:1: entryRuleValidID returns [String current=null] : iv_ruleValidID= ruleValidID EOF ;
+    public final String entryRuleValidID() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleValidID = null;
+
+
+        try {
+            // InternalOXtype.g:6831:47: (iv_ruleValidID= ruleValidID EOF )
+            // InternalOXtype.g:6832:2: iv_ruleValidID= ruleValidID EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getValidIDRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleValidID=ruleValidID();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleValidID.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleValidID"
+
+
+    // $ANTLR start "ruleValidID"
+    // InternalOXtype.g:6838:1: ruleValidID returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : this_ID_0= RULE_ID ;
+    public final AntlrDatatypeRuleToken ruleValidID() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token this_ID_0=null;
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6844:2: (this_ID_0= RULE_ID )
+            // InternalOXtype.g:6845:2: this_ID_0= RULE_ID
+            {
+            this_ID_0=(Token)match(input,RULE_ID,FOLLOW_2); if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+
+              		current.merge(this_ID_0);
+              	
+            }
+            if ( state.backtracking==0 ) {
+
+              		newLeafNode(this_ID_0, grammarAccess.getValidIDAccess().getIDTerminalRuleCall());
+              	
+            }
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleValidID"
+
+
+    // $ANTLR start "entryRuleQualifiedNameInStaticImport"
+    // InternalOXtype.g:6855:1: entryRuleQualifiedNameInStaticImport returns [String current=null] : iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF ;
+    public final String entryRuleQualifiedNameInStaticImport() throws RecognitionException {
+        String current = null;
+
+        AntlrDatatypeRuleToken iv_ruleQualifiedNameInStaticImport = null;
+
+
+        try {
+            // InternalOXtype.g:6855:67: (iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF )
+            // InternalOXtype.g:6856:2: iv_ruleQualifiedNameInStaticImport= ruleQualifiedNameInStaticImport EOF
+            {
+            if ( state.backtracking==0 ) {
+               newCompositeNode(grammarAccess.getQualifiedNameInStaticImportRule()); 
+            }
+            pushFollow(FOLLOW_1);
+            iv_ruleQualifiedNameInStaticImport=ruleQualifiedNameInStaticImport();
+
+            state._fsp--;
+            if (state.failed) return current;
+            if ( state.backtracking==0 ) {
+               current =iv_ruleQualifiedNameInStaticImport.getText(); 
+            }
+            match(input,EOF,FOLLOW_2); if (state.failed) return current;
+
+            }
+
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "entryRuleQualifiedNameInStaticImport"
+
+
+    // $ANTLR start "ruleQualifiedNameInStaticImport"
+    // InternalOXtype.g:6862:1: ruleQualifiedNameInStaticImport returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ValidID_0= ruleValidID kw= '.' )+ ;
+    public final AntlrDatatypeRuleToken ruleQualifiedNameInStaticImport() throws RecognitionException {
+        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();
+
+        Token kw=null;
+        AntlrDatatypeRuleToken this_ValidID_0 = null;
+
+
+
+        	enterRule();
+
+        try {
+            // InternalOXtype.g:6868:2: ( (this_ValidID_0= ruleValidID kw= '.' )+ )
+            // InternalOXtype.g:6869:2: (this_ValidID_0= ruleValidID kw= '.' )+
+            {
+            // InternalOXtype.g:6869:2: (this_ValidID_0= ruleValidID kw= '.' )+
+            int cnt122=0;
+            loop122:
+            do {
+                int alt122=2;
+                int LA122_0 = input.LA(1);
+
+                if ( (LA122_0==RULE_ID) ) {
+                    int LA122_2 = input.LA(2);
+
+                    if ( (LA122_2==57) ) {
+                        alt122=1;
+                    }
+
+
+                }
+
+
+                switch (alt122) {
+            	case 1 :
+            	    // InternalOXtype.g:6870:3: this_ValidID_0= ruleValidID kw= '.'
+            	    {
+            	    if ( state.backtracking==0 ) {
+
+            	      			newCompositeNode(grammarAccess.getQualifiedNameInStaticImportAccess().getValidIDParserRuleCall_0());
+            	      		
+            	    }
+            	    pushFollow(FOLLOW_84);
+            	    this_ValidID_0=ruleValidID();
+
+            	    state._fsp--;
+            	    if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      			current.merge(this_ValidID_0);
+            	      		
+            	    }
+            	    if ( state.backtracking==0 ) {
+
+            	      			afterParserOrEnumRuleCall();
+            	      		
+            	    }
+            	    kw=(Token)match(input,57,FOLLOW_86); if (state.failed) return current;
+            	    if ( state.backtracking==0 ) {
+
+            	      			current.merge(kw);
+            	      			newLeafNode(kw, grammarAccess.getQualifiedNameInStaticImportAccess().getFullStopKeyword_1());
+            	      		
+            	    }
+
+            	    }
+            	    break;
+
+            	default :
+            	    if ( cnt122 >= 1 ) break loop122;
+            	    if (state.backtracking>0) {state.failed=true; return current;}
+                        EarlyExitException eee =
+                            new EarlyExitException(122, input);
+                        throw eee;
+                }
+                cnt122++;
+            } while (true);
+
+
+            }
+
+            if ( state.backtracking==0 ) {
+
+              	leaveRule();
+
+            }
+        }
+
+            catch (RecognitionException re) {
+                recover(input,re);
+                appendSkippedTokens();
+            }
+        finally {
+        }
+        return current;
+    }
+    // $ANTLR end "ruleQualifiedNameInStaticImport"
+
+    // $ANTLR start synpred1_InternalOXtype
+    public final void synpred1_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:301:5: ( '(' )
+        // InternalOXtype.g:301:6: '('
+        {
+        match(input,20,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred1_InternalOXtype
+
+    // $ANTLR start synpred2_InternalOXtype
+    public final void synpred2_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:310:7: ( ( ( ( ruleValidID ) ) '=' ) )
+        // InternalOXtype.g:310:8: ( ( ( ruleValidID ) ) '=' )
+        {
+        // InternalOXtype.g:310:8: ( ( ( ruleValidID ) ) '=' )
+        // InternalOXtype.g:311:8: ( ( ruleValidID ) ) '='
+        {
+        // InternalOXtype.g:311:8: ( ( ruleValidID ) )
+        // InternalOXtype.g:312:9: ( ruleValidID )
+        {
+        // InternalOXtype.g:312:9: ( ruleValidID )
+        // InternalOXtype.g:313:10: ruleValidID
+        {
+        pushFollow(FOLLOW_12);
+        ruleValidID();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+        match(input,23,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred2_InternalOXtype
+
+    // $ANTLR start synpred5_InternalOXtype
+    public final void synpred5_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:490:5: ( ( () '#' '[' ) )
+        // InternalOXtype.g:490:6: ( () '#' '[' )
+        {
+        // InternalOXtype.g:490:6: ( () '#' '[' )
+        // InternalOXtype.g:491:6: () '#' '['
+        {
+        // InternalOXtype.g:491:6: ()
+        // InternalOXtype.g:492:6: 
+        {
+        }
+
+        match(input,24,FOLLOW_14); if (state.failed) return ;
+        match(input,25,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred5_InternalOXtype
+
+    // $ANTLR start synpred6_InternalOXtype
+    public final void synpred6_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:632:5: ( ( () '#' '[' ) )
+        // InternalOXtype.g:632:6: ( () '#' '[' )
+        {
+        // InternalOXtype.g:632:6: ( () '#' '[' )
+        // InternalOXtype.g:633:6: () '#' '['
+        {
+        // InternalOXtype.g:633:6: ()
+        // InternalOXtype.g:634:6: 
+        {
+        }
+
+        match(input,24,FOLLOW_14); if (state.failed) return ;
+        match(input,25,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred6_InternalOXtype
+
+    // $ANTLR start synpred7_InternalOXtype
+    public final void synpred7_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:860:6: ( ( () ( ( ruleOpMultiAssign ) ) ) )
+        // InternalOXtype.g:860:7: ( () ( ( ruleOpMultiAssign ) ) )
+        {
+        // InternalOXtype.g:860:7: ( () ( ( ruleOpMultiAssign ) ) )
+        // InternalOXtype.g:861:7: () ( ( ruleOpMultiAssign ) )
+        {
+        // InternalOXtype.g:861:7: ()
+        // InternalOXtype.g:862:7: 
+        {
+        }
+
+        // InternalOXtype.g:863:7: ( ( ruleOpMultiAssign ) )
+        // InternalOXtype.g:864:8: ( ruleOpMultiAssign )
+        {
+        // InternalOXtype.g:864:8: ( ruleOpMultiAssign )
+        // InternalOXtype.g:865:9: ruleOpMultiAssign
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpMultiAssign();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred7_InternalOXtype
+
+    // $ANTLR start synpred8_InternalOXtype
+    public final void synpred8_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1054:5: ( ( () ( ( ruleOpOr ) ) ) )
+        // InternalOXtype.g:1054:6: ( () ( ( ruleOpOr ) ) )
+        {
+        // InternalOXtype.g:1054:6: ( () ( ( ruleOpOr ) ) )
+        // InternalOXtype.g:1055:6: () ( ( ruleOpOr ) )
+        {
+        // InternalOXtype.g:1055:6: ()
+        // InternalOXtype.g:1056:6: 
+        {
+        }
+
+        // InternalOXtype.g:1057:6: ( ( ruleOpOr ) )
+        // InternalOXtype.g:1058:7: ( ruleOpOr )
+        {
+        // InternalOXtype.g:1058:7: ( ruleOpOr )
+        // InternalOXtype.g:1059:8: ruleOpOr
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpOr();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred8_InternalOXtype
+
+    // $ANTLR start synpred9_InternalOXtype
+    public final void synpred9_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1161:5: ( ( () ( ( ruleOpAnd ) ) ) )
+        // InternalOXtype.g:1161:6: ( () ( ( ruleOpAnd ) ) )
+        {
+        // InternalOXtype.g:1161:6: ( () ( ( ruleOpAnd ) ) )
+        // InternalOXtype.g:1162:6: () ( ( ruleOpAnd ) )
+        {
+        // InternalOXtype.g:1162:6: ()
+        // InternalOXtype.g:1163:6: 
+        {
+        }
+
+        // InternalOXtype.g:1164:6: ( ( ruleOpAnd ) )
+        // InternalOXtype.g:1165:7: ( ruleOpAnd )
+        {
+        // InternalOXtype.g:1165:7: ( ruleOpAnd )
+        // InternalOXtype.g:1166:8: ruleOpAnd
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpAnd();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred9_InternalOXtype
+
+    // $ANTLR start synpred10_InternalOXtype
+    public final void synpred10_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1268:5: ( ( () ( ( ruleOpEquality ) ) ) )
+        // InternalOXtype.g:1268:6: ( () ( ( ruleOpEquality ) ) )
+        {
+        // InternalOXtype.g:1268:6: ( () ( ( ruleOpEquality ) ) )
+        // InternalOXtype.g:1269:6: () ( ( ruleOpEquality ) )
+        {
+        // InternalOXtype.g:1269:6: ()
+        // InternalOXtype.g:1270:6: 
+        {
+        }
+
+        // InternalOXtype.g:1271:6: ( ( ruleOpEquality ) )
+        // InternalOXtype.g:1272:7: ( ruleOpEquality )
+        {
+        // InternalOXtype.g:1272:7: ( ruleOpEquality )
+        // InternalOXtype.g:1273:8: ruleOpEquality
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpEquality();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred10_InternalOXtype
+
+    // $ANTLR start synpred11_InternalOXtype
+    public final void synpred11_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1396:6: ( ( () 'instanceof' ) )
+        // InternalOXtype.g:1396:7: ( () 'instanceof' )
+        {
+        // InternalOXtype.g:1396:7: ( () 'instanceof' )
+        // InternalOXtype.g:1397:7: () 'instanceof'
+        {
+        // InternalOXtype.g:1397:7: ()
+        // InternalOXtype.g:1398:7: 
+        {
+        }
+
+        match(input,41,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred11_InternalOXtype
+
+    // $ANTLR start synpred12_InternalOXtype
+    public final void synpred12_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1439:6: ( ( () ( ( ruleOpCompare ) ) ) )
+        // InternalOXtype.g:1439:7: ( () ( ( ruleOpCompare ) ) )
+        {
+        // InternalOXtype.g:1439:7: ( () ( ( ruleOpCompare ) ) )
+        // InternalOXtype.g:1440:7: () ( ( ruleOpCompare ) )
+        {
+        // InternalOXtype.g:1440:7: ()
+        // InternalOXtype.g:1441:7: 
+        {
+        }
+
+        // InternalOXtype.g:1442:7: ( ( ruleOpCompare ) )
+        // InternalOXtype.g:1443:8: ( ruleOpCompare )
+        {
+        // InternalOXtype.g:1443:8: ( ruleOpCompare )
+        // InternalOXtype.g:1444:9: ruleOpCompare
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpCompare();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred12_InternalOXtype
+
+    // $ANTLR start synpred13_InternalOXtype
+    public final void synpred13_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1574:5: ( ( () ( ( ruleOpOther ) ) ) )
+        // InternalOXtype.g:1574:6: ( () ( ( ruleOpOther ) ) )
+        {
+        // InternalOXtype.g:1574:6: ( () ( ( ruleOpOther ) ) )
+        // InternalOXtype.g:1575:6: () ( ( ruleOpOther ) )
+        {
+        // InternalOXtype.g:1575:6: ()
+        // InternalOXtype.g:1576:6: 
+        {
+        }
+
+        // InternalOXtype.g:1577:6: ( ( ruleOpOther ) )
+        // InternalOXtype.g:1578:7: ( ruleOpOther )
+        {
+        // InternalOXtype.g:1578:7: ( ruleOpOther )
+        // InternalOXtype.g:1579:8: ruleOpOther
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpOther();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred13_InternalOXtype
+
+    // $ANTLR start synpred14_InternalOXtype
+    public final void synpred14_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1694:6: ( ( '>' '>' ) )
+        // InternalOXtype.g:1694:7: ( '>' '>' )
+        {
+        // InternalOXtype.g:1694:7: ( '>' '>' )
+        // InternalOXtype.g:1695:7: '>' '>'
+        {
+        match(input,33,FOLLOW_29); if (state.failed) return ;
+        match(input,33,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred14_InternalOXtype
+
+    // $ANTLR start synpred15_InternalOXtype
+    public final void synpred15_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1729:6: ( ( '<' '<' ) )
+        // InternalOXtype.g:1729:7: ( '<' '<' )
+        {
+        // InternalOXtype.g:1729:7: ( '<' '<' )
+        // InternalOXtype.g:1730:7: '<' '<'
+        {
+        match(input,32,FOLLOW_19); if (state.failed) return ;
+        match(input,32,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred15_InternalOXtype
+
+    // $ANTLR start synpred16_InternalOXtype
+    public final void synpred16_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1802:5: ( ( () ( ( ruleOpAdd ) ) ) )
+        // InternalOXtype.g:1802:6: ( () ( ( ruleOpAdd ) ) )
+        {
+        // InternalOXtype.g:1802:6: ( () ( ( ruleOpAdd ) ) )
+        // InternalOXtype.g:1803:6: () ( ( ruleOpAdd ) )
+        {
+        // InternalOXtype.g:1803:6: ()
+        // InternalOXtype.g:1804:6: 
+        {
+        }
+
+        // InternalOXtype.g:1805:6: ( ( ruleOpAdd ) )
+        // InternalOXtype.g:1806:7: ( ruleOpAdd )
+        {
+        // InternalOXtype.g:1806:7: ( ruleOpAdd )
+        // InternalOXtype.g:1807:8: ruleOpAdd
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpAdd();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred16_InternalOXtype
+
+    // $ANTLR start synpred17_InternalOXtype
+    public final void synpred17_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:1917:5: ( ( () ( ( ruleOpMulti ) ) ) )
+        // InternalOXtype.g:1917:6: ( () ( ( ruleOpMulti ) ) )
+        {
+        // InternalOXtype.g:1917:6: ( () ( ( ruleOpMulti ) ) )
+        // InternalOXtype.g:1918:6: () ( ( ruleOpMulti ) )
+        {
+        // InternalOXtype.g:1918:6: ()
+        // InternalOXtype.g:1919:6: 
+        {
+        }
+
+        // InternalOXtype.g:1920:6: ( ( ruleOpMulti ) )
+        // InternalOXtype.g:1921:7: ( ruleOpMulti )
+        {
+        // InternalOXtype.g:1921:7: ( ruleOpMulti )
+        // InternalOXtype.g:1922:8: ruleOpMulti
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpMulti();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred17_InternalOXtype
+
+    // $ANTLR start synpred18_InternalOXtype
+    public final void synpred18_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2152:5: ( ( () 'as' ) )
+        // InternalOXtype.g:2152:6: ( () 'as' )
+        {
+        // InternalOXtype.g:2152:6: ( () 'as' )
+        // InternalOXtype.g:2153:6: () 'as'
+        {
+        // InternalOXtype.g:2153:6: ()
+        // InternalOXtype.g:2154:6: 
+        {
+        }
+
+        match(input,54,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred18_InternalOXtype
+
+    // $ANTLR start synpred19_InternalOXtype
+    public final void synpred19_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2220:4: ( ( () ( ( ruleOpPostfix ) ) ) )
+        // InternalOXtype.g:2220:5: ( () ( ( ruleOpPostfix ) ) )
+        {
+        // InternalOXtype.g:2220:5: ( () ( ( ruleOpPostfix ) ) )
+        // InternalOXtype.g:2221:5: () ( ( ruleOpPostfix ) )
+        {
+        // InternalOXtype.g:2221:5: ()
+        // InternalOXtype.g:2222:5: 
+        {
+        }
+
+        // InternalOXtype.g:2223:5: ( ( ruleOpPostfix ) )
+        // InternalOXtype.g:2224:6: ( ruleOpPostfix )
+        {
+        // InternalOXtype.g:2224:6: ( ruleOpPostfix )
+        // InternalOXtype.g:2225:7: ruleOpPostfix
+        {
+        pushFollow(FOLLOW_2);
+        ruleOpPostfix();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred19_InternalOXtype
+
+    // $ANTLR start synpred20_InternalOXtype
+    public final void synpred20_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2316:6: ( ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign ) )
+        // InternalOXtype.g:2316:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+        {
+        // InternalOXtype.g:2316:7: ( () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign )
+        // InternalOXtype.g:2317:7: () ( '.' | ( ( '::' ) ) ) ( ( ruleFeatureCallID ) ) ruleOpSingleAssign
+        {
+        // InternalOXtype.g:2317:7: ()
+        // InternalOXtype.g:2318:7: 
+        {
+        }
+
+        // InternalOXtype.g:2319:7: ( '.' | ( ( '::' ) ) )
+        int alt123=2;
+        int LA123_0 = input.LA(1);
+
+        if ( (LA123_0==57) ) {
+            alt123=1;
+        }
+        else if ( (LA123_0==58) ) {
+            alt123=2;
+        }
+        else {
+            if (state.backtracking>0) {state.failed=true; return ;}
+            NoViableAltException nvae =
+                new NoViableAltException("", 123, 0, input);
+
+            throw nvae;
+        }
+        switch (alt123) {
+            case 1 :
+                // InternalOXtype.g:2320:8: '.'
+                {
+                match(input,57,FOLLOW_36); if (state.failed) return ;
+
+                }
+                break;
+            case 2 :
+                // InternalOXtype.g:2322:8: ( ( '::' ) )
+                {
+                // InternalOXtype.g:2322:8: ( ( '::' ) )
+                // InternalOXtype.g:2323:9: ( '::' )
+                {
+                // InternalOXtype.g:2323:9: ( '::' )
+                // InternalOXtype.g:2324:10: '::'
+                {
+                match(input,58,FOLLOW_36); if (state.failed) return ;
+
+                }
+
+
+                }
+
+
+                }
+                break;
+
+        }
+
+        // InternalOXtype.g:2328:7: ( ( ruleFeatureCallID ) )
+        // InternalOXtype.g:2329:8: ( ruleFeatureCallID )
+        {
+        // InternalOXtype.g:2329:8: ( ruleFeatureCallID )
+        // InternalOXtype.g:2330:9: ruleFeatureCallID
+        {
+        pushFollow(FOLLOW_12);
+        ruleFeatureCallID();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+        pushFollow(FOLLOW_2);
+        ruleOpSingleAssign();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred20_InternalOXtype
+
+    // $ANTLR start synpred21_InternalOXtype
+    public final void synpred21_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2413:6: ( ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) ) )
+        // InternalOXtype.g:2413:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) )
+        {
+        // InternalOXtype.g:2413:7: ( () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) ) )
+        // InternalOXtype.g:2414:7: () ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) )
+        {
+        // InternalOXtype.g:2414:7: ()
+        // InternalOXtype.g:2415:7: 
+        {
+        }
+
+        // InternalOXtype.g:2416:7: ( '.' | ( ( '?.' ) ) | ( ( '::' ) ) )
+        int alt124=3;
+        switch ( input.LA(1) ) {
+        case 57:
+            {
+            alt124=1;
+            }
+            break;
+        case 59:
+            {
+            alt124=2;
+            }
+            break;
+        case 58:
+            {
+            alt124=3;
+            }
+            break;
+        default:
+            if (state.backtracking>0) {state.failed=true; return ;}
+            NoViableAltException nvae =
+                new NoViableAltException("", 124, 0, input);
+
+            throw nvae;
+        }
+
+        switch (alt124) {
+            case 1 :
+                // InternalOXtype.g:2417:8: '.'
+                {
+                match(input,57,FOLLOW_2); if (state.failed) return ;
+
+                }
+                break;
+            case 2 :
+                // InternalOXtype.g:2419:8: ( ( '?.' ) )
+                {
+                // InternalOXtype.g:2419:8: ( ( '?.' ) )
+                // InternalOXtype.g:2420:9: ( '?.' )
+                {
+                // InternalOXtype.g:2420:9: ( '?.' )
+                // InternalOXtype.g:2421:10: '?.'
+                {
+                match(input,59,FOLLOW_2); if (state.failed) return ;
+
+                }
+
+
+                }
+
+
+                }
+                break;
+            case 3 :
+                // InternalOXtype.g:2425:8: ( ( '::' ) )
+                {
+                // InternalOXtype.g:2425:8: ( ( '::' ) )
+                // InternalOXtype.g:2426:9: ( '::' )
+                {
+                // InternalOXtype.g:2426:9: ( '::' )
+                // InternalOXtype.g:2427:10: '::'
+                {
+                match(input,58,FOLLOW_2); if (state.failed) return ;
+
+                }
+
+
+                }
+
+
+                }
+                break;
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred21_InternalOXtype
+
+    // $ANTLR start synpred22_InternalOXtype
+    public final void synpred22_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2551:7: ( ( '(' ) )
+        // InternalOXtype.g:2551:8: ( '(' )
+        {
+        // InternalOXtype.g:2551:8: ( '(' )
+        // InternalOXtype.g:2552:8: '('
+        {
+        match(input,20,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred22_InternalOXtype
+
+    // $ANTLR start synpred23_InternalOXtype
+    public final void synpred23_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2570:8: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+        // InternalOXtype.g:2570:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        {
+        // InternalOXtype.g:2570:9: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        // InternalOXtype.g:2571:9: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+        {
+        // InternalOXtype.g:2571:9: ()
+        // InternalOXtype.g:2572:9: 
+        {
+        }
+
+        // InternalOXtype.g:2573:9: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+        int alt126=2;
+        int LA126_0 = input.LA(1);
+
+        if ( (LA126_0==RULE_ID||LA126_0==20||LA126_0==45) ) {
+            alt126=1;
+        }
+        switch (alt126) {
+            case 1 :
+                // InternalOXtype.g:2574:10: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                {
+                // InternalOXtype.g:2574:10: ( ( ruleJvmFormalParameter ) )
+                // InternalOXtype.g:2575:11: ( ruleJvmFormalParameter )
+                {
+                // InternalOXtype.g:2575:11: ( ruleJvmFormalParameter )
+                // InternalOXtype.g:2576:12: ruleJvmFormalParameter
+                {
+                pushFollow(FOLLOW_47);
+                ruleJvmFormalParameter();
+
+                state._fsp--;
+                if (state.failed) return ;
+
+                }
+
+
+                }
+
+                // InternalOXtype.g:2579:10: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                loop125:
+                do {
+                    int alt125=2;
+                    int LA125_0 = input.LA(1);
+
+                    if ( (LA125_0==21) ) {
+                        alt125=1;
+                    }
+
+
+                    switch (alt125) {
+                	case 1 :
+                	    // InternalOXtype.g:2580:11: ',' ( ( ruleJvmFormalParameter ) )
+                	    {
+                	    match(input,21,FOLLOW_26); if (state.failed) return ;
+                	    // InternalOXtype.g:2581:11: ( ( ruleJvmFormalParameter ) )
+                	    // InternalOXtype.g:2582:12: ( ruleJvmFormalParameter )
+                	    {
+                	    // InternalOXtype.g:2582:12: ( ruleJvmFormalParameter )
+                	    // InternalOXtype.g:2583:13: ruleJvmFormalParameter
+                	    {
+                	    pushFollow(FOLLOW_47);
+                	    ruleJvmFormalParameter();
+
+                	    state._fsp--;
+                	    if (state.failed) return ;
+
+                	    }
+
+
+                	    }
+
+
+                	    }
+                	    break;
+
+                	default :
+                	    break loop125;
+                    }
+                } while (true);
+
+
+                }
+                break;
+
+        }
+
+        // InternalOXtype.g:2588:9: ( ( '|' ) )
+        // InternalOXtype.g:2589:10: ( '|' )
+        {
+        // InternalOXtype.g:2589:10: ( '|' )
+        // InternalOXtype.g:2590:11: '|'
+        {
+        match(input,62,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred23_InternalOXtype
+
+    // $ANTLR start synpred24_InternalOXtype
+    public final void synpred24_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2667:6: ( ( () '[' ) )
+        // InternalOXtype.g:2667:7: ( () '[' )
+        {
+        // InternalOXtype.g:2667:7: ( () '[' )
+        // InternalOXtype.g:2668:7: () '['
+        {
+        // InternalOXtype.g:2668:7: ()
+        // InternalOXtype.g:2669:7: 
+        {
+        }
+
+        match(input,25,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred24_InternalOXtype
+
+    // $ANTLR start synpred25_InternalOXtype
+    public final void synpred25_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2740:4: ( ( () 'synchronized' '(' ) )
+        // InternalOXtype.g:2740:5: ( () 'synchronized' '(' )
+        {
+        // InternalOXtype.g:2740:5: ( () 'synchronized' '(' )
+        // InternalOXtype.g:2741:5: () 'synchronized' '('
+        {
+        // InternalOXtype.g:2741:5: ()
+        // InternalOXtype.g:2742:5: 
+        {
+        }
+
+        match(input,85,FOLLOW_52); if (state.failed) return ;
+        match(input,20,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred25_InternalOXtype
+
+    // $ANTLR start synpred26_InternalOXtype
+    public final void synpred26_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2785:4: ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )
+        // InternalOXtype.g:2785:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' )
+        {
+        // InternalOXtype.g:2785:5: ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' )
+        // InternalOXtype.g:2786:5: () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':'
+        {
+        // InternalOXtype.g:2786:5: ()
+        // InternalOXtype.g:2787:5: 
+        {
+        }
+
+        match(input,69,FOLLOW_52); if (state.failed) return ;
+        match(input,20,FOLLOW_26); if (state.failed) return ;
+        // InternalOXtype.g:2790:5: ( ( ruleJvmFormalParameter ) )
+        // InternalOXtype.g:2791:6: ( ruleJvmFormalParameter )
+        {
+        // InternalOXtype.g:2791:6: ( ruleJvmFormalParameter )
+        // InternalOXtype.g:2792:7: ruleJvmFormalParameter
+        {
+        pushFollow(FOLLOW_55);
+        ruleJvmFormalParameter();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+        match(input,66,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred26_InternalOXtype
+
+    // $ANTLR start synpred27_InternalOXtype
+    public final void synpred27_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:2899:4: ( ( () '[' ) )
+        // InternalOXtype.g:2899:5: ( () '[' )
+        {
+        // InternalOXtype.g:2899:5: ( () '[' )
+        // InternalOXtype.g:2900:5: () '['
+        {
+        // InternalOXtype.g:2900:5: ()
+        // InternalOXtype.g:2901:5: 
+        {
+        }
+
+        match(input,25,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred27_InternalOXtype
+
+    // $ANTLR start synpred29_InternalOXtype
+    public final void synpred29_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:3204:4: ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+        // InternalOXtype.g:3204:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        {
+        // InternalOXtype.g:3204:5: ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        // InternalOXtype.g:3205:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+        {
+        // InternalOXtype.g:3205:5: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+        int alt128=2;
+        int LA128_0 = input.LA(1);
+
+        if ( (LA128_0==RULE_ID||LA128_0==20||LA128_0==45) ) {
+            alt128=1;
+        }
+        switch (alt128) {
+            case 1 :
+                // InternalOXtype.g:3206:6: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                {
+                // InternalOXtype.g:3206:6: ( ( ruleJvmFormalParameter ) )
+                // InternalOXtype.g:3207:7: ( ruleJvmFormalParameter )
+                {
+                // InternalOXtype.g:3207:7: ( ruleJvmFormalParameter )
+                // InternalOXtype.g:3208:8: ruleJvmFormalParameter
+                {
+                pushFollow(FOLLOW_47);
+                ruleJvmFormalParameter();
+
+                state._fsp--;
+                if (state.failed) return ;
+
+                }
+
+
+                }
+
+                // InternalOXtype.g:3211:6: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                loop127:
+                do {
+                    int alt127=2;
+                    int LA127_0 = input.LA(1);
+
+                    if ( (LA127_0==21) ) {
+                        alt127=1;
+                    }
+
+
+                    switch (alt127) {
+                	case 1 :
+                	    // InternalOXtype.g:3212:7: ',' ( ( ruleJvmFormalParameter ) )
+                	    {
+                	    match(input,21,FOLLOW_26); if (state.failed) return ;
+                	    // InternalOXtype.g:3213:7: ( ( ruleJvmFormalParameter ) )
+                	    // InternalOXtype.g:3214:8: ( ruleJvmFormalParameter )
+                	    {
+                	    // InternalOXtype.g:3214:8: ( ruleJvmFormalParameter )
+                	    // InternalOXtype.g:3215:9: ruleJvmFormalParameter
+                	    {
+                	    pushFollow(FOLLOW_47);
+                	    ruleJvmFormalParameter();
+
+                	    state._fsp--;
+                	    if (state.failed) return ;
+
+                	    }
+
+
+                	    }
+
+
+                	    }
+                	    break;
+
+                	default :
+                	    break loop127;
+                    }
+                } while (true);
+
+
+                }
+                break;
+
+        }
+
+        // InternalOXtype.g:3220:5: ( ( '|' ) )
+        // InternalOXtype.g:3221:6: ( '|' )
+        {
+        // InternalOXtype.g:3221:6: ( '|' )
+        // InternalOXtype.g:3222:7: '|'
+        {
+        match(input,62,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred29_InternalOXtype
+
+    // $ANTLR start synpred31_InternalOXtype
+    public final void synpred31_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:3613:5: ( 'else' )
+        // InternalOXtype.g:3613:6: 'else'
+        {
+        match(input,64,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred31_InternalOXtype
+
+    // $ANTLR start synpred32_InternalOXtype
+    public final void synpred32_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:3672:6: ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )
+        // InternalOXtype.g:3672:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' )
+        {
+        // InternalOXtype.g:3672:7: ( '(' ( ( ruleJvmFormalParameter ) ) ':' )
+        // InternalOXtype.g:3673:7: '(' ( ( ruleJvmFormalParameter ) ) ':'
+        {
+        match(input,20,FOLLOW_26); if (state.failed) return ;
+        // InternalOXtype.g:3674:7: ( ( ruleJvmFormalParameter ) )
+        // InternalOXtype.g:3675:8: ( ruleJvmFormalParameter )
+        {
+        // InternalOXtype.g:3675:8: ( ruleJvmFormalParameter )
+        // InternalOXtype.g:3676:9: ruleJvmFormalParameter
+        {
+        pushFollow(FOLLOW_55);
+        ruleJvmFormalParameter();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+        match(input,66,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred32_InternalOXtype
+
+    // $ANTLR start synpred33_InternalOXtype
+    public final void synpred33_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:3739:6: ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )
+        // InternalOXtype.g:3739:7: ( ( ( ruleJvmFormalParameter ) ) ':' )
+        {
+        // InternalOXtype.g:3739:7: ( ( ( ruleJvmFormalParameter ) ) ':' )
+        // InternalOXtype.g:3740:7: ( ( ruleJvmFormalParameter ) ) ':'
+        {
+        // InternalOXtype.g:3740:7: ( ( ruleJvmFormalParameter ) )
+        // InternalOXtype.g:3741:8: ( ruleJvmFormalParameter )
+        {
+        // InternalOXtype.g:3741:8: ( ruleJvmFormalParameter )
+        // InternalOXtype.g:3742:9: ruleJvmFormalParameter
+        {
+        pushFollow(FOLLOW_55);
+        ruleJvmFormalParameter();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+        match(input,66,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred33_InternalOXtype
+
+    // $ANTLR start synpred35_InternalOXtype
+    public final void synpred35_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:4557:5: ( ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) ) )
+        // InternalOXtype.g:4557:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) )
+        {
+        // InternalOXtype.g:4557:6: ( ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) ) )
+        // InternalOXtype.g:4558:6: ( ( ruleJvmTypeReference ) ) ( ( ruleValidID ) )
+        {
+        // InternalOXtype.g:4558:6: ( ( ruleJvmTypeReference ) )
+        // InternalOXtype.g:4559:7: ( ruleJvmTypeReference )
+        {
+        // InternalOXtype.g:4559:7: ( ruleJvmTypeReference )
+        // InternalOXtype.g:4560:8: ruleJvmTypeReference
+        {
+        pushFollow(FOLLOW_7);
+        ruleJvmTypeReference();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+        // InternalOXtype.g:4563:6: ( ( ruleValidID ) )
+        // InternalOXtype.g:4564:7: ( ruleValidID )
+        {
+        // InternalOXtype.g:4564:7: ( ruleValidID )
+        // InternalOXtype.g:4565:8: ruleValidID
+        {
+        pushFollow(FOLLOW_2);
+        ruleValidID();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred35_InternalOXtype
+
+    // $ANTLR start synpred36_InternalOXtype
+    public final void synpred36_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:4869:5: ( ( '(' ) )
+        // InternalOXtype.g:4869:6: ( '(' )
+        {
+        // InternalOXtype.g:4869:6: ( '(' )
+        // InternalOXtype.g:4870:6: '('
+        {
+        match(input,20,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred36_InternalOXtype
+
+    // $ANTLR start synpred37_InternalOXtype
+    public final void synpred37_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:4888:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+        // InternalOXtype.g:4888:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        {
+        // InternalOXtype.g:4888:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        // InternalOXtype.g:4889:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+        {
+        // InternalOXtype.g:4889:7: ()
+        // InternalOXtype.g:4890:7: 
+        {
+        }
+
+        // InternalOXtype.g:4891:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+        int alt132=2;
+        int LA132_0 = input.LA(1);
+
+        if ( (LA132_0==RULE_ID||LA132_0==20||LA132_0==45) ) {
+            alt132=1;
+        }
+        switch (alt132) {
+            case 1 :
+                // InternalOXtype.g:4892:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                {
+                // InternalOXtype.g:4892:8: ( ( ruleJvmFormalParameter ) )
+                // InternalOXtype.g:4893:9: ( ruleJvmFormalParameter )
+                {
+                // InternalOXtype.g:4893:9: ( ruleJvmFormalParameter )
+                // InternalOXtype.g:4894:10: ruleJvmFormalParameter
+                {
+                pushFollow(FOLLOW_47);
+                ruleJvmFormalParameter();
+
+                state._fsp--;
+                if (state.failed) return ;
+
+                }
+
+
+                }
+
+                // InternalOXtype.g:4897:8: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                loop131:
+                do {
+                    int alt131=2;
+                    int LA131_0 = input.LA(1);
+
+                    if ( (LA131_0==21) ) {
+                        alt131=1;
+                    }
+
+
+                    switch (alt131) {
+                	case 1 :
+                	    // InternalOXtype.g:4898:9: ',' ( ( ruleJvmFormalParameter ) )
+                	    {
+                	    match(input,21,FOLLOW_26); if (state.failed) return ;
+                	    // InternalOXtype.g:4899:9: ( ( ruleJvmFormalParameter ) )
+                	    // InternalOXtype.g:4900:10: ( ruleJvmFormalParameter )
+                	    {
+                	    // InternalOXtype.g:4900:10: ( ruleJvmFormalParameter )
+                	    // InternalOXtype.g:4901:11: ruleJvmFormalParameter
+                	    {
+                	    pushFollow(FOLLOW_47);
+                	    ruleJvmFormalParameter();
+
+                	    state._fsp--;
+                	    if (state.failed) return ;
+
+                	    }
+
+
+                	    }
+
+
+                	    }
+                	    break;
+
+                	default :
+                	    break loop131;
+                    }
+                } while (true);
+
+
+                }
+                break;
+
+        }
+
+        // InternalOXtype.g:4906:7: ( ( '|' ) )
+        // InternalOXtype.g:4907:8: ( '|' )
+        {
+        // InternalOXtype.g:4907:8: ( '|' )
+        // InternalOXtype.g:4908:9: '|'
+        {
+        match(input,62,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred37_InternalOXtype
+
+    // $ANTLR start synpred38_InternalOXtype
+    public final void synpred38_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:4985:4: ( ( () '[' ) )
+        // InternalOXtype.g:4985:5: ( () '[' )
+        {
+        // InternalOXtype.g:4985:5: ( () '[' )
+        // InternalOXtype.g:4986:5: () '['
+        {
+        // InternalOXtype.g:4986:5: ()
+        // InternalOXtype.g:4987:5: 
+        {
+        }
+
+        match(input,25,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred38_InternalOXtype
+
+    // $ANTLR start synpred39_InternalOXtype
+    public final void synpred39_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5145:5: ( '<' )
+        // InternalOXtype.g:5145:6: '<'
+        {
+        match(input,32,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred39_InternalOXtype
+
+    // $ANTLR start synpred40_InternalOXtype
+    public final void synpred40_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5202:5: ( ( '(' ) )
+        // InternalOXtype.g:5202:6: ( '(' )
+        {
+        // InternalOXtype.g:5202:6: ( '(' )
+        // InternalOXtype.g:5203:6: '('
+        {
+        match(input,20,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred40_InternalOXtype
+
+    // $ANTLR start synpred41_InternalOXtype
+    public final void synpred41_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5221:6: ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )
+        // InternalOXtype.g:5221:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        {
+        // InternalOXtype.g:5221:7: ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) )
+        // InternalOXtype.g:5222:7: () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) )
+        {
+        // InternalOXtype.g:5222:7: ()
+        // InternalOXtype.g:5223:7: 
+        {
+        }
+
+        // InternalOXtype.g:5224:7: ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )?
+        int alt134=2;
+        int LA134_0 = input.LA(1);
+
+        if ( (LA134_0==RULE_ID||LA134_0==20||LA134_0==45) ) {
+            alt134=1;
+        }
+        switch (alt134) {
+            case 1 :
+                // InternalOXtype.g:5225:8: ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                {
+                // InternalOXtype.g:5225:8: ( ( ruleJvmFormalParameter ) )
+                // InternalOXtype.g:5226:9: ( ruleJvmFormalParameter )
+                {
+                // InternalOXtype.g:5226:9: ( ruleJvmFormalParameter )
+                // InternalOXtype.g:5227:10: ruleJvmFormalParameter
+                {
+                pushFollow(FOLLOW_47);
+                ruleJvmFormalParameter();
+
+                state._fsp--;
+                if (state.failed) return ;
+
+                }
+
+
+                }
+
+                // InternalOXtype.g:5230:8: ( ',' ( ( ruleJvmFormalParameter ) ) )*
+                loop133:
+                do {
+                    int alt133=2;
+                    int LA133_0 = input.LA(1);
+
+                    if ( (LA133_0==21) ) {
+                        alt133=1;
+                    }
+
+
+                    switch (alt133) {
+                	case 1 :
+                	    // InternalOXtype.g:5231:9: ',' ( ( ruleJvmFormalParameter ) )
+                	    {
+                	    match(input,21,FOLLOW_26); if (state.failed) return ;
+                	    // InternalOXtype.g:5232:9: ( ( ruleJvmFormalParameter ) )
+                	    // InternalOXtype.g:5233:10: ( ruleJvmFormalParameter )
+                	    {
+                	    // InternalOXtype.g:5233:10: ( ruleJvmFormalParameter )
+                	    // InternalOXtype.g:5234:11: ruleJvmFormalParameter
+                	    {
+                	    pushFollow(FOLLOW_47);
+                	    ruleJvmFormalParameter();
+
+                	    state._fsp--;
+                	    if (state.failed) return ;
+
+                	    }
+
+
+                	    }
+
+
+                	    }
+                	    break;
+
+                	default :
+                	    break loop133;
+                    }
+                } while (true);
+
+
+                }
+                break;
+
+        }
+
+        // InternalOXtype.g:5239:7: ( ( '|' ) )
+        // InternalOXtype.g:5240:8: ( '|' )
+        {
+        // InternalOXtype.g:5240:8: ( '|' )
+        // InternalOXtype.g:5241:9: '|'
+        {
+        match(input,62,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred41_InternalOXtype
+
+    // $ANTLR start synpred42_InternalOXtype
+    public final void synpred42_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5318:4: ( ( () '[' ) )
+        // InternalOXtype.g:5318:5: ( () '[' )
+        {
+        // InternalOXtype.g:5318:5: ( () '[' )
+        // InternalOXtype.g:5319:5: () '['
+        {
+        // InternalOXtype.g:5319:5: ()
+        // InternalOXtype.g:5320:5: 
+        {
+        }
+
+        match(input,25,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred42_InternalOXtype
+
+    // $ANTLR start synpred43_InternalOXtype
+    public final void synpred43_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5661:4: ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )
+        // InternalOXtype.g:
+        {
+        if ( (input.LA(1)>=RULE_STRING && input.LA(1)<=RULE_ID)||(input.LA(1)>=13 && input.LA(1)<=15)||input.LA(1)==20||(input.LA(1)>=24 && input.LA(1)<=25)||input.LA(1)==32||(input.LA(1)>=48 && input.LA(1)<=49)||input.LA(1)==53||input.LA(1)==60||input.LA(1)==63||input.LA(1)==65||(input.LA(1)>=69 && input.LA(1)<=71)||(input.LA(1)>=74 && input.LA(1)<=83)||input.LA(1)==85 ) {
+            input.consume();
+            state.errorRecovery=false;state.failed=false;
+        }
+        else {
+            if (state.backtracking>0) {state.failed=true; return ;}
+            MismatchedSetException mse = new MismatchedSetException(null,input);
+            throw mse;
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred43_InternalOXtype
+
+    // $ANTLR start synpred44_InternalOXtype
+    public final void synpred44_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5732:6: ( 'catch' )
+        // InternalOXtype.g:5732:7: 'catch'
+        {
+        match(input,86,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred44_InternalOXtype
+
+    // $ANTLR start synpred45_InternalOXtype
+    public final void synpred45_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5753:7: ( 'finally' )
+        // InternalOXtype.g:5753:8: 'finally'
+        {
+        match(input,84,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred45_InternalOXtype
+
+    // $ANTLR start synpred48_InternalOXtype
+    public final void synpred48_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:5997:5: ( '.' )
+        // InternalOXtype.g:5997:6: '.'
+        {
+        match(input,57,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred48_InternalOXtype
+
+    // $ANTLR start synpred49_InternalOXtype
+    public final void synpred49_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6123:5: ( ( () ruleArrayBrackets ) )
+        // InternalOXtype.g:6123:6: ( () ruleArrayBrackets )
+        {
+        // InternalOXtype.g:6123:6: ( () ruleArrayBrackets )
+        // InternalOXtype.g:6124:6: () ruleArrayBrackets
+        {
+        // InternalOXtype.g:6124:6: ()
+        // InternalOXtype.g:6125:6: 
+        {
+        }
+
+        pushFollow(FOLLOW_2);
+        ruleArrayBrackets();
+
+        state._fsp--;
+        if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred49_InternalOXtype
+
+    // $ANTLR start synpred50_InternalOXtype
+    public final void synpred50_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6320:5: ( '<' )
+        // InternalOXtype.g:6320:6: '<'
+        {
+        match(input,32,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred50_InternalOXtype
+
+    // $ANTLR start synpred51_InternalOXtype
+    public final void synpred51_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6376:6: ( ( () '.' ) )
+        // InternalOXtype.g:6376:7: ( () '.' )
+        {
+        // InternalOXtype.g:6376:7: ( () '.' )
+        // InternalOXtype.g:6377:7: () '.'
+        {
+        // InternalOXtype.g:6377:7: ()
+        // InternalOXtype.g:6378:7: 
+        {
+        }
+
+        match(input,57,FOLLOW_2); if (state.failed) return ;
+
+        }
+
+
+        }
+    }
+    // $ANTLR end synpred51_InternalOXtype
+
+    // $ANTLR start synpred52_InternalOXtype
+    public final void synpred52_InternalOXtype_fragment() throws RecognitionException {   
+        // InternalOXtype.g:6414:7: ( '<' )
+        // InternalOXtype.g:6414:8: '<'
+        {
+        match(input,32,FOLLOW_2); if (state.failed) return ;
+
+        }
+    }
+    // $ANTLR end synpred52_InternalOXtype
+
+    // Delegated rules
+
+    public final boolean synpred35_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred35_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred48_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred48_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred22_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred22_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred8_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred8_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred19_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred19_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred13_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred13_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred9_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred9_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred39_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred39_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred52_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred52_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred43_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred43_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred26_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred26_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred10_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred10_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred15_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred15_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred23_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred23_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred31_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred31_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred49_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred49_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred36_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred36_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred18_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred18_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred44_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred44_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred14_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred14_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred27_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred27_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred40_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred40_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred1_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred1_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred16_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred16_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred33_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred33_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred20_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred20_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred32_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred32_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred37_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred37_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred45_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred45_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred24_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred24_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred5_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred5_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred11_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred11_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred41_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred41_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred7_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred7_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred42_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred42_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred2_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred2_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred17_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred17_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred21_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred21_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred50_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred50_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred25_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred25_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred51_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred51_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred38_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred38_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred6_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred6_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred29_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred29_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+    public final boolean synpred12_InternalOXtype() {
+        state.backtracking++;
+        int start = input.mark();
+        try {
+            synpred12_InternalOXtype_fragment(); // can never throw exception
+        } catch (RecognitionException re) {
+            System.err.println("impossible: "+re);
+        }
+        boolean success = !state.failed;
+        input.rewind(start);
+        state.backtracking--;
+        state.failed=false;
+        return success;
+    }
+
+
+    protected DFA3 dfa3 = new DFA3(this);
+    protected DFA6 dfa6 = new DFA6(this);
+    protected DFA12 dfa12 = new DFA12(this);
+    protected DFA15 dfa15 = new DFA15(this);
+    protected DFA17 dfa17 = new DFA17(this);
+    protected DFA27 dfa27 = new DFA27(this);
+    protected DFA30 dfa30 = new DFA30(this);
+    protected DFA46 dfa46 = new DFA46(this);
+    protected DFA45 dfa45 = new DFA45(this);
+    protected DFA47 dfa47 = new DFA47(this);
+    protected DFA49 dfa49 = new DFA49(this);
+    protected DFA58 dfa58 = new DFA58(this);
+    protected DFA65 dfa65 = new DFA65(this);
+    protected DFA64 dfa64 = new DFA64(this);
+    protected DFA87 dfa87 = new DFA87(this);
+    protected DFA86 dfa86 = new DFA86(this);
+    protected DFA88 dfa88 = new DFA88(this);
+    protected DFA92 dfa92 = new DFA92(this);
+    protected DFA95 dfa95 = new DFA95(this);
+    protected DFA94 dfa94 = new DFA94(this);
+    protected DFA96 dfa96 = new DFA96(this);
+    protected DFA99 dfa99 = new DFA99(this);
+    protected DFA117 dfa117 = new DFA117(this);
+    protected DFA115 dfa115 = new DFA115(this);
+    static final String dfa_1s = "\10\uffff";
+    static final String dfa_2s = "\2\uffff\1\5\3\uffff\1\5\1\uffff";
+    static final String dfa_3s = "\1\10\1\uffff\1\22\1\uffff\1\10\1\uffff\1\22\1\uffff";
+    static final String dfa_4s = "\1\21\1\uffff\1\71\1\uffff\1\20\1\uffff\1\71\1\uffff";
+    static final String dfa_5s = "\1\uffff\1\1\1\uffff\1\4\1\uffff\1\2\1\uffff\1\3";
+    static final String dfa_6s = "\10\uffff}>";
+    static final String[] dfa_7s = {
+            "\1\2\5\uffff\1\1\2\uffff\1\3",
+            "",
+            "\1\5\46\uffff\1\4",
+            "",
+            "\1\6\7\uffff\1\7",
+            "",
+            "\1\5\46\uffff\1\4",
+            ""
+    };
+
+    static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
+    static final short[] dfa_2 = DFA.unpackEncodedString(dfa_2s);
+    static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
+    static final char[] dfa_4 = DFA.unpackEncodedStringToUnsignedChars(dfa_4s);
+    static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
+    static final short[] dfa_6 = DFA.unpackEncodedString(dfa_6s);
+    static final short[][] dfa_7 = unpackEncodedStringArray(dfa_7s);
+
+    class DFA3 extends DFA {
+
+        public DFA3(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 3;
+            this.eot = dfa_1;
+            this.eof = dfa_2;
+            this.min = dfa_3;
+            this.max = dfa_4;
+            this.accept = dfa_5;
+            this.special = dfa_6;
+            this.transition = dfa_7;
+        }
+        public String getDescription() {
+            return "90:3: ( ( ( (lv_static_2_0= 'static' ) ) ( (lv_extension_3_0= 'extension' ) )? ( ( ruleQualifiedNameInStaticImport ) ) ( ( (lv_wildcard_5_0= '*' ) ) | ( (lv_memberName_6_0= ruleValidID ) ) ) ) | ( ( ruleQualifiedName ) ) | ( (lv_importedNamespace_8_0= ruleQualifiedNameWithWildcard ) ) | ( ( (lv_fqnImport_9_0= 'ns' ) ) ( (lv_importedFullyQualifiedName_10_0= ruleQualifiedName ) ) ) )";
+        }
+    }
+    static final String dfa_8s = "\44\uffff";
+    static final String dfa_9s = "\1\4\1\0\42\uffff";
+    static final String dfa_10s = "\1\125\1\0\42\uffff";
+    static final String dfa_11s = "\2\uffff\1\2\37\uffff\1\3\1\1";
+    static final String dfa_12s = "\1\uffff\1\0\42\uffff}>";
+    static final String[] dfa_13s = {
+            "\4\2\1\1\4\uffff\3\2\3\uffff\2\2\1\uffff\1\42\1\uffff\2\2\6\uffff\1\2\17\uffff\2\2\3\uffff\1\2\6\uffff\1\2\2\uffff\1\2\1\uffff\1\2\3\uffff\3\2\2\uffff\12\2\1\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_8 = DFA.unpackEncodedString(dfa_8s);
+    static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
+    static final char[] dfa_10 = DFA.unpackEncodedStringToUnsignedChars(dfa_10s);
+    static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
+    static final short[] dfa_12 = DFA.unpackEncodedString(dfa_12s);
+    static final short[][] dfa_13 = unpackEncodedStringArray(dfa_13s);
+
+    class DFA6 extends DFA {
+
+        public DFA6(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 6;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_9;
+            this.max = dfa_10;
+            this.accept = dfa_11;
+            this.special = dfa_12;
+            this.transition = dfa_13;
+        }
+        public String getDescription() {
+            return "307:4: ( ( ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_4_0= ruleXAnnotationElementValuePair ) ) (otherlv_5= ',' ( ( ( ( ( ruleValidID ) ) '=' ) )=> (lv_elementValuePairs_6_0= ruleXAnnotationElementValuePair ) ) )* ) | ( (lv_value_7_0= ruleXAnnotationElementValueOrCommaList ) ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA6_1 = input.LA(1);
+
+                         
+                        int index6_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred2_InternalOXtype()) ) {s = 35;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index6_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 6, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_14s = "\43\uffff";
+    static final String dfa_15s = "\1\4\1\0\41\uffff";
+    static final String dfa_16s = "\1\125\1\0\41\uffff";
+    static final String dfa_17s = "\2\uffff\1\2\37\uffff\1\1";
+    static final String dfa_18s = "\1\uffff\1\0\41\uffff}>";
+    static final String[] dfa_19s = {
+            "\5\2\4\uffff\3\2\3\uffff\2\2\3\uffff\1\1\1\2\6\uffff\1\2\17\uffff\2\2\3\uffff\1\2\6\uffff\1\2\2\uffff\1\2\1\uffff\1\2\3\uffff\3\2\2\uffff\12\2\1\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_14 = DFA.unpackEncodedString(dfa_14s);
+    static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s);
+    static final char[] dfa_16 = DFA.unpackEncodedStringToUnsignedChars(dfa_16s);
+    static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s);
+    static final short[] dfa_18 = DFA.unpackEncodedString(dfa_18s);
+    static final short[][] dfa_19 = unpackEncodedStringArray(dfa_19s);
+
+    class DFA12 extends DFA {
+
+        public DFA12(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 12;
+            this.eot = dfa_14;
+            this.eof = dfa_14;
+            this.min = dfa_15;
+            this.max = dfa_16;
+            this.accept = dfa_17;
+            this.special = dfa_18;
+            this.transition = dfa_19;
+        }
+        public String getDescription() {
+            return "487:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | (this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression ( () (otherlv_9= ',' ( (lv_elements_10_0= ruleXAnnotationOrExpression ) ) )+ )? ) )";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA12_1 = input.LA(1);
+
+                         
+                        int index12_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred5_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index12_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 12, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA15 extends DFA {
+
+        public DFA15(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 15;
+            this.eot = dfa_14;
+            this.eof = dfa_14;
+            this.min = dfa_15;
+            this.max = dfa_16;
+            this.accept = dfa_17;
+            this.special = dfa_18;
+            this.transition = dfa_19;
+        }
+        public String getDescription() {
+            return "629:2: ( ( ( ( ( () '#' '[' ) )=> ( () otherlv_1= '#' otherlv_2= '[' ) ) ( ( (lv_elements_3_0= ruleXAnnotationOrExpression ) ) (otherlv_4= ',' ( (lv_elements_5_0= ruleXAnnotationOrExpression ) ) )* )? otherlv_6= ']' ) | this_XAnnotationOrExpression_7= ruleXAnnotationOrExpression )";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA15_1 = input.LA(1);
+
+                         
+                        int index15_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred6_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index15_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 15, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_20s = "\12\uffff";
+    static final String dfa_21s = "\1\10\11\uffff";
+    static final String dfa_22s = "\1\4\7\0\2\uffff";
+    static final String dfa_23s = "\1\126\7\0\2\uffff";
+    static final String dfa_24s = "\10\uffff\1\2\1\1";
+    static final String dfa_25s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\2\uffff}>";
+    static final String[] dfa_26s = {
+            "\5\10\4\uffff\4\10\1\uffff\1\10\1\uffff\3\10\1\uffff\3\10\1\1\1\2\1\3\1\4\1\5\1\6\1\7\34\10\1\uffff\30\10",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            ""
+    };
+
+    static final short[] dfa_20 = DFA.unpackEncodedString(dfa_20s);
+    static final short[] dfa_21 = DFA.unpackEncodedString(dfa_21s);
+    static final char[] dfa_22 = DFA.unpackEncodedStringToUnsignedChars(dfa_22s);
+    static final char[] dfa_23 = DFA.unpackEncodedStringToUnsignedChars(dfa_23s);
+    static final short[] dfa_24 = DFA.unpackEncodedString(dfa_24s);
+    static final short[] dfa_25 = DFA.unpackEncodedString(dfa_25s);
+    static final short[][] dfa_26 = unpackEncodedStringArray(dfa_26s);
+
+    class DFA17 extends DFA {
+
+        public DFA17(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 17;
+            this.eot = dfa_20;
+            this.eof = dfa_21;
+            this.min = dfa_22;
+            this.max = dfa_23;
+            this.accept = dfa_24;
+            this.special = dfa_25;
+            this.transition = dfa_26;
+        }
+        public String getDescription() {
+            return "858:4: ( ( ( ( () ( ( ruleOpMultiAssign ) ) ) )=> ( () ( ( ruleOpMultiAssign ) ) ) ) ( (lv_rightOperand_7_0= ruleXAssignment ) ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA17_1 = input.LA(1);
+
+                         
+                        int index17_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA17_2 = input.LA(1);
+
+                         
+                        int index17_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_2);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA17_3 = input.LA(1);
+
+                         
+                        int index17_3 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_3);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 3 : 
+                        int LA17_4 = input.LA(1);
+
+                         
+                        int index17_4 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_4);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 4 : 
+                        int LA17_5 = input.LA(1);
+
+                         
+                        int index17_5 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_5);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 5 : 
+                        int LA17_6 = input.LA(1);
+
+                         
+                        int index17_6 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_6);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 6 : 
+                        int LA17_7 = input.LA(1);
+
+                         
+                        int index17_7 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred7_InternalOXtype()) ) {s = 9;}
+
+                        else if ( (true) ) {s = 8;}
+
+                         
+                        input.seek(index17_7);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 17, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_27s = "\13\uffff";
+    static final String dfa_28s = "\1\1\12\uffff";
+    static final String dfa_29s = "\1\4\1\uffff\10\0\1\uffff";
+    static final String dfa_30s = "\1\126\1\uffff\10\0\1\uffff";
+    static final String dfa_31s = "\1\uffff\1\2\10\uffff\1\1";
+    static final String dfa_32s = "\2\uffff\1\3\1\5\1\0\1\1\1\4\1\2\1\6\1\7\1\uffff}>";
+    static final String[] dfa_33s = {
+            "\5\1\4\uffff\4\1\1\uffff\1\1\1\uffff\3\1\1\uffff\10\1\1\2\1\3\10\1\1\4\1\5\1\6\1\7\1\10\1\11\16\1\1\uffff\30\1",
+            "",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            ""
+    };
+
+    static final short[] dfa_27 = DFA.unpackEncodedString(dfa_27s);
+    static final short[] dfa_28 = DFA.unpackEncodedString(dfa_28s);
+    static final char[] dfa_29 = DFA.unpackEncodedStringToUnsignedChars(dfa_29s);
+    static final char[] dfa_30 = DFA.unpackEncodedStringToUnsignedChars(dfa_30s);
+    static final short[] dfa_31 = DFA.unpackEncodedString(dfa_31s);
+    static final short[] dfa_32 = DFA.unpackEncodedString(dfa_32s);
+    static final short[][] dfa_33 = unpackEncodedStringArray(dfa_33s);
+
+    class DFA27 extends DFA {
+
+        public DFA27(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 27;
+            this.eot = dfa_27;
+            this.eof = dfa_28;
+            this.min = dfa_29;
+            this.max = dfa_30;
+            this.accept = dfa_31;
+            this.special = dfa_32;
+            this.transition = dfa_33;
+        }
+        public String getDescription() {
+            return "()* loopback of 1572:3: ( ( ( ( () ( ( ruleOpOther ) ) ) )=> ( () ( ( ruleOpOther ) ) ) ) ( (lv_rightOperand_3_0= ruleXAdditiveExpression ) ) )*";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA27_4 = input.LA(1);
+
+                         
+                        int index27_4 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_4);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA27_5 = input.LA(1);
+
+                         
+                        int index27_5 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_5);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA27_7 = input.LA(1);
+
+                         
+                        int index27_7 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_7);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 3 : 
+                        int LA27_2 = input.LA(1);
+
+                         
+                        int index27_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_2);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 4 : 
+                        int LA27_6 = input.LA(1);
+
+                         
+                        int index27_6 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_6);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 5 : 
+                        int LA27_3 = input.LA(1);
+
+                         
+                        int index27_3 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_3);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 6 : 
+                        int LA27_8 = input.LA(1);
+
+                         
+                        int index27_8 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_8);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 7 : 
+                        int LA27_9 = input.LA(1);
+
+                         
+                        int index27_9 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred13_InternalOXtype()) ) {s = 10;}
+
+                        else if ( (true) ) {s = 1;}
+
+                         
+                        input.seek(index27_9);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 27, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_34s = "\1\40\2\uffff\1\41\7\uffff";
+    static final String dfa_35s = "\1\57\2\uffff\1\54\7\uffff";
+    static final String dfa_36s = "\1\uffff\1\1\1\2\1\uffff\1\4\1\5\1\7\1\10\1\11\1\3\1\6";
+    static final String dfa_37s = "\13\uffff}>";
+    static final String[] dfa_38s = {
+            "\1\6\1\3\10\uffff\1\1\1\2\1\4\1\5\1\7\1\10",
+            "",
+            "",
+            "\1\12\12\uffff\1\11",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final char[] dfa_34 = DFA.unpackEncodedStringToUnsignedChars(dfa_34s);
+    static final char[] dfa_35 = DFA.unpackEncodedStringToUnsignedChars(dfa_35s);
+    static final short[] dfa_36 = DFA.unpackEncodedString(dfa_36s);
+    static final short[] dfa_37 = DFA.unpackEncodedString(dfa_37s);
+    static final short[][] dfa_38 = unpackEncodedStringArray(dfa_38s);
+
+    class DFA30 extends DFA {
+
+        public DFA30(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 30;
+            this.eot = dfa_27;
+            this.eof = dfa_27;
+            this.min = dfa_34;
+            this.max = dfa_35;
+            this.accept = dfa_36;
+            this.special = dfa_37;
+            this.transition = dfa_38;
+        }
+        public String getDescription() {
+            return "1648:2: (kw= '->' | kw= '..<' | (kw= '>' kw= '..' ) | kw= '..' | kw= '=>' | (kw= '>' ( ( ( ( '>' '>' ) )=> (kw= '>' kw= '>' ) ) | kw= '>' ) ) | (kw= '<' ( ( ( ( '<' '<' ) )=> (kw= '<' kw= '<' ) ) | kw= '<' | kw= '=>' ) ) | kw= '<>' | kw= '?:' )";
+        }
+    }
+    static final String dfa_39s = "\116\uffff";
+    static final String dfa_40s = "\1\2\115\uffff";
+    static final String dfa_41s = "\1\4\1\0\114\uffff";
+    static final String dfa_42s = "\1\126\1\0\114\uffff";
+    static final String dfa_43s = "\2\uffff\1\2\112\uffff\1\1";
+    static final String dfa_44s = "\1\uffff\1\0\114\uffff}>";
+    static final String[] dfa_45s = {
+            "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\1\1\2\2\1\uffff\46\2\1\uffff\30\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_39 = DFA.unpackEncodedString(dfa_39s);
+    static final short[] dfa_40 = DFA.unpackEncodedString(dfa_40s);
+    static final char[] dfa_41 = DFA.unpackEncodedStringToUnsignedChars(dfa_41s);
+    static final char[] dfa_42 = DFA.unpackEncodedStringToUnsignedChars(dfa_42s);
+    static final short[] dfa_43 = DFA.unpackEncodedString(dfa_43s);
+    static final short[] dfa_44 = DFA.unpackEncodedString(dfa_44s);
+    static final short[][] dfa_45 = unpackEncodedStringArray(dfa_45s);
+
+    class DFA46 extends DFA {
+
+        public DFA46(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 46;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_45;
+        }
+        public String getDescription() {
+            return "2549:5: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_17_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )? otherlv_22= ')' )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA46_1 = input.LA(1);
+
+                         
+                        int index46_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred22_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index46_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 46, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_46s = "\1\4\2\0\41\uffff";
+    static final String dfa_47s = "\1\125\2\0\41\uffff";
+    static final String dfa_48s = "\3\uffff\2\1\1\2\35\uffff\1\3";
+    static final String dfa_49s = "\1\0\1\1\1\2\41\uffff}>";
+    static final String[] dfa_50s = {
+            "\4\5\1\1\4\uffff\3\5\4\uffff\1\2\1\uffff\1\43\1\uffff\2\5\6\uffff\1\5\14\uffff\1\3\2\uffff\2\5\3\uffff\1\5\6\uffff\1\5\1\uffff\1\4\1\5\1\uffff\1\5\3\uffff\3\5\2\uffff\12\5\1\uffff\1\5",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final char[] dfa_46 = DFA.unpackEncodedStringToUnsignedChars(dfa_46s);
+    static final char[] dfa_47 = DFA.unpackEncodedStringToUnsignedChars(dfa_47s);
+    static final short[] dfa_48 = DFA.unpackEncodedString(dfa_48s);
+    static final short[] dfa_49 = DFA.unpackEncodedString(dfa_49s);
+    static final short[][] dfa_50 = unpackEncodedStringArray(dfa_50s);
+
+    class DFA45 extends DFA {
+
+        public DFA45(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 45;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_46;
+            this.max = dfa_47;
+            this.accept = dfa_48;
+            this.special = dfa_49;
+            this.transition = dfa_50;
+        }
+        public String getDescription() {
+            return "2568:6: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_memberCallArguments_18_0= ruleXShortClosure ) ) | ( ( (lv_memberCallArguments_19_0= ruleXExpression ) ) (otherlv_20= ',' ( (lv_memberCallArguments_21_0= ruleXExpression ) ) )* ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA45_0 = input.LA(1);
+
+                         
+                        int index45_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA45_0==RULE_ID) ) {s = 1;}
+
+                        else if ( (LA45_0==20) ) {s = 2;}
+
+                        else if ( (LA45_0==45) && (synpred23_InternalOXtype())) {s = 3;}
+
+                        else if ( (LA45_0==62) && (synpred23_InternalOXtype())) {s = 4;}
+
+                        else if ( ((LA45_0>=RULE_STRING && LA45_0<=RULE_DECIMAL)||(LA45_0>=13 && LA45_0<=15)||(LA45_0>=24 && LA45_0<=25)||LA45_0==32||(LA45_0>=48 && LA45_0<=49)||LA45_0==53||LA45_0==60||LA45_0==63||LA45_0==65||(LA45_0>=69 && LA45_0<=71)||(LA45_0>=74 && LA45_0<=83)||LA45_0==85) ) {s = 5;}
+
+                        else if ( (LA45_0==22) ) {s = 35;}
+
+                         
+                        input.seek(index45_0);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA45_1 = input.LA(1);
+
+                         
+                        int index45_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred23_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index45_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA45_2 = input.LA(1);
+
+                         
+                        int index45_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred23_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index45_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 45, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_51s = {
+            "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\3\2\1\uffff\1\2\1\1\44\2\1\uffff\30\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_51 = unpackEncodedStringArray(dfa_51s);
+
+    class DFA47 extends DFA {
+
+        public DFA47(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 47;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_51;
+        }
+        public String getDescription() {
+            return "2666:5: ( ( ( () '[' ) )=> (lv_memberCallArguments_23_0= ruleXClosure ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA47_1 = input.LA(1);
+
+                         
+                        int index47_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred24_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index47_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 47, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_52s = "\40\uffff";
+    static final String dfa_53s = "\1\4\26\uffff\1\0\10\uffff";
+    static final String dfa_54s = "\1\125\26\uffff\1\0\10\uffff";
+    static final String dfa_55s = "\1\uffff\1\1\1\2\1\3\1\4\1\5\6\uffff\1\6\11\uffff\1\7\1\uffff\1\12\1\13\1\14\1\15\1\16\1\17\1\10\1\11";
+    static final String dfa_56s = "\1\0\26\uffff\1\1\10\uffff}>";
+    static final String[] dfa_57s = {
+            "\4\14\1\5\4\uffff\3\5\4\uffff\1\35\3\uffff\2\14\6\uffff\1\5\33\uffff\1\2\2\uffff\1\26\1\uffff\1\3\3\uffff\1\27\1\30\1\31\2\uffff\2\5\1\1\4\14\1\32\1\33\1\34\1\uffff\1\4",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_52 = DFA.unpackEncodedString(dfa_52s);
+    static final char[] dfa_53 = DFA.unpackEncodedStringToUnsignedChars(dfa_53s);
+    static final char[] dfa_54 = DFA.unpackEncodedStringToUnsignedChars(dfa_54s);
+    static final short[] dfa_55 = DFA.unpackEncodedString(dfa_55s);
+    static final short[] dfa_56 = DFA.unpackEncodedString(dfa_56s);
+    static final short[][] dfa_57 = unpackEncodedStringArray(dfa_57s);
+
+    class DFA49 extends DFA {
+
+        public DFA49(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 49;
+            this.eot = dfa_52;
+            this.eof = dfa_52;
+            this.min = dfa_53;
+            this.max = dfa_54;
+            this.accept = dfa_55;
+            this.special = dfa_56;
+            this.transition = dfa_57;
+        }
+        public String getDescription() {
+            return "2711:2: (this_XConstructorCall_0= ruleXConstructorCall | this_XBlockExpression_1= ruleXBlockExpression | this_XSwitchExpression_2= ruleXSwitchExpression | ( ( ( () 'synchronized' '(' ) )=>this_XSynchronizedExpression_3= ruleXSynchronizedExpression ) | this_XFeatureCall_4= ruleXFeatureCall | this_XLiteral_5= ruleXLiteral | this_XIfExpression_6= ruleXIfExpression | ( ( ( () 'for' '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=>this_XForLoopExpression_7= ruleXForLoopExpression ) | this_XBasicForLoopExpression_8= ruleXBasicForLoopExpression | this_XWhileExpression_9= ruleXWhileExpression | this_XDoWhileExpression_10= ruleXDoWhileExpression | this_XThrowExpression_11= ruleXThrowExpression | this_XReturnExpression_12= ruleXReturnExpression | this_XTryCatchFinallyExpression_13= ruleXTryCatchFinallyExpression | this_XParenthesizedExpression_14= ruleXParenthesizedExpression )";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA49_0 = input.LA(1);
+
+                         
+                        int index49_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA49_0==76) ) {s = 1;}
+
+                        else if ( (LA49_0==60) ) {s = 2;}
+
+                        else if ( (LA49_0==65) ) {s = 3;}
+
+                        else if ( (LA49_0==85) && (synpred25_InternalOXtype())) {s = 4;}
+
+                        else if ( (LA49_0==RULE_ID||(LA49_0>=13 && LA49_0<=15)||LA49_0==32||(LA49_0>=74 && LA49_0<=75)) ) {s = 5;}
+
+                        else if ( ((LA49_0>=RULE_STRING && LA49_0<=RULE_DECIMAL)||(LA49_0>=24 && LA49_0<=25)||(LA49_0>=77 && LA49_0<=80)) ) {s = 12;}
+
+                        else if ( (LA49_0==63) ) {s = 22;}
+
+                        else if ( (LA49_0==69) ) {s = 23;}
+
+                        else if ( (LA49_0==70) ) {s = 24;}
+
+                        else if ( (LA49_0==71) ) {s = 25;}
+
+                        else if ( (LA49_0==81) ) {s = 26;}
+
+                        else if ( (LA49_0==82) ) {s = 27;}
+
+                        else if ( (LA49_0==83) ) {s = 28;}
+
+                        else if ( (LA49_0==20) ) {s = 29;}
+
+                         
+                        input.seek(index49_0);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA49_23 = input.LA(1);
+
+                         
+                        int index49_23 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred26_InternalOXtype()) ) {s = 30;}
+
+                        else if ( (true) ) {s = 31;}
+
+                         
+                        input.seek(index49_23);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 49, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_58s = "\46\uffff";
+    static final String dfa_59s = "\1\4\2\0\43\uffff";
+    static final String dfa_60s = "\1\125\2\0\43\uffff";
+    static final String dfa_61s = "\3\uffff\2\1\1\2\40\uffff";
+    static final String dfa_62s = "\1\0\1\1\1\2\43\uffff}>";
+    static final String[] dfa_63s = {
+            "\4\5\1\1\4\uffff\3\5\4\uffff\1\2\3\uffff\3\5\5\uffff\1\5\14\uffff\1\3\2\uffff\2\5\3\uffff\1\5\6\uffff\1\5\1\uffff\1\4\1\5\1\uffff\1\5\3\uffff\17\5\1\uffff\1\5",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_58 = DFA.unpackEncodedString(dfa_58s);
+    static final char[] dfa_59 = DFA.unpackEncodedStringToUnsignedChars(dfa_59s);
+    static final char[] dfa_60 = DFA.unpackEncodedStringToUnsignedChars(dfa_60s);
+    static final short[] dfa_61 = DFA.unpackEncodedString(dfa_61s);
+    static final short[] dfa_62 = DFA.unpackEncodedString(dfa_62s);
+    static final short[][] dfa_63 = unpackEncodedStringArray(dfa_63s);
+
+    class DFA58 extends DFA {
+
+        public DFA58(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 58;
+            this.eot = dfa_58;
+            this.eof = dfa_58;
+            this.min = dfa_59;
+            this.max = dfa_60;
+            this.accept = dfa_61;
+            this.special = dfa_62;
+            this.transition = dfa_63;
+        }
+        public String getDescription() {
+            return "3203:3: ( ( ( ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> ( ( ( (lv_declaredFormalParameters_2_0= ruleJvmFormalParameter ) ) (otherlv_3= ',' ( (lv_declaredFormalParameters_4_0= ruleJvmFormalParameter ) ) )* )? ( (lv_explicitSyntax_5_0= '|' ) ) ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA58_0 = input.LA(1);
+
+                         
+                        int index58_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA58_0==RULE_ID) ) {s = 1;}
+
+                        else if ( (LA58_0==20) ) {s = 2;}
+
+                        else if ( (LA58_0==45) && (synpred29_InternalOXtype())) {s = 3;}
+
+                        else if ( (LA58_0==62) && (synpred29_InternalOXtype())) {s = 4;}
+
+                        else if ( ((LA58_0>=RULE_STRING && LA58_0<=RULE_DECIMAL)||(LA58_0>=13 && LA58_0<=15)||(LA58_0>=24 && LA58_0<=26)||LA58_0==32||(LA58_0>=48 && LA58_0<=49)||LA58_0==53||LA58_0==60||LA58_0==63||LA58_0==65||(LA58_0>=69 && LA58_0<=83)||LA58_0==85) ) {s = 5;}
+
+                         
+                        input.seek(index58_0);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA58_1 = input.LA(1);
+
+                         
+                        int index58_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred29_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index58_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA58_2 = input.LA(1);
+
+                         
+                        int index58_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred29_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index58_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 58, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_64s = {
+            "\5\2\4\uffff\3\2\4\uffff\1\1\3\uffff\2\2\6\uffff\1\2\14\uffff\1\2\2\uffff\2\2\3\uffff\1\2\6\uffff\1\2\2\uffff\1\2\1\uffff\1\2\3\uffff\3\2\2\uffff\12\2\1\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_64 = unpackEncodedStringArray(dfa_64s);
+
+    class DFA65 extends DFA {
+
+        public DFA65(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 65;
+            this.eot = dfa_14;
+            this.eof = dfa_14;
+            this.min = dfa_15;
+            this.max = dfa_16;
+            this.accept = dfa_17;
+            this.special = dfa_18;
+            this.transition = dfa_64;
+        }
+        public String getDescription() {
+            return "3669:3: ( ( ( ( ( '(' ( ( ruleJvmFormalParameter ) ) ':' ) )=> (otherlv_2= '(' ( (lv_declaredParam_3_0= ruleJvmFormalParameter ) ) otherlv_4= ':' ) ) ( (lv_switch_5_0= ruleXExpression ) ) otherlv_6= ')' ) | ( ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )? ( (lv_switch_9_0= ruleXExpression ) ) ) )";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA65_1 = input.LA(1);
+
+                         
+                        int index65_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred32_InternalOXtype()) ) {s = 34;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index65_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 65, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_65s = "\42\uffff";
+    static final String dfa_66s = "\1\4\2\0\37\uffff";
+    static final String dfa_67s = "\1\125\2\0\37\uffff";
+    static final String dfa_68s = "\3\uffff\1\1\1\2\35\uffff";
+    static final String dfa_69s = "\1\0\1\1\1\2\37\uffff}>";
+    static final String[] dfa_70s = {
+            "\4\4\1\1\4\uffff\3\4\4\uffff\1\2\3\uffff\2\4\6\uffff\1\4\14\uffff\1\3\2\uffff\2\4\3\uffff\1\4\6\uffff\1\4\2\uffff\1\4\1\uffff\1\4\3\uffff\3\4\2\uffff\12\4\1\uffff\1\4",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_65 = DFA.unpackEncodedString(dfa_65s);
+    static final char[] dfa_66 = DFA.unpackEncodedStringToUnsignedChars(dfa_66s);
+    static final char[] dfa_67 = DFA.unpackEncodedStringToUnsignedChars(dfa_67s);
+    static final short[] dfa_68 = DFA.unpackEncodedString(dfa_68s);
+    static final short[] dfa_69 = DFA.unpackEncodedString(dfa_69s);
+    static final short[][] dfa_70 = unpackEncodedStringArray(dfa_70s);
+
+    class DFA64 extends DFA {
+
+        public DFA64(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 64;
+            this.eot = dfa_65;
+            this.eof = dfa_65;
+            this.min = dfa_66;
+            this.max = dfa_67;
+            this.accept = dfa_68;
+            this.special = dfa_69;
+            this.transition = dfa_70;
+        }
+        public String getDescription() {
+            return "3738:5: ( ( ( ( ( ruleJvmFormalParameter ) ) ':' ) )=> ( ( (lv_declaredParam_7_0= ruleJvmFormalParameter ) ) otherlv_8= ':' ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA64_0 = input.LA(1);
+
+                         
+                        int index64_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA64_0==RULE_ID) ) {s = 1;}
+
+                        else if ( (LA64_0==20) ) {s = 2;}
+
+                        else if ( (LA64_0==45) && (synpred33_InternalOXtype())) {s = 3;}
+
+                        else if ( ((LA64_0>=RULE_STRING && LA64_0<=RULE_DECIMAL)||(LA64_0>=13 && LA64_0<=15)||(LA64_0>=24 && LA64_0<=25)||LA64_0==32||(LA64_0>=48 && LA64_0<=49)||LA64_0==53||LA64_0==60||LA64_0==63||LA64_0==65||(LA64_0>=69 && LA64_0<=71)||(LA64_0>=74 && LA64_0<=83)||LA64_0==85) ) {s = 4;}
+
+                         
+                        input.seek(index64_0);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA64_1 = input.LA(1);
+
+                         
+                        int index64_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred33_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 4;}
+
+                         
+                        input.seek(index64_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA64_2 = input.LA(1);
+
+                         
+                        int index64_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred33_InternalOXtype()) ) {s = 3;}
+
+                        else if ( (true) ) {s = 4;}
+
+                         
+                        input.seek(index64_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 64, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA87 extends DFA {
+
+        public DFA87(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 87;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_45;
+        }
+        public String getDescription() {
+            return "4867:3: ( ( ( ( '(' ) )=> (lv_explicitOperationCall_7_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )? otherlv_12= ')' )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA87_1 = input.LA(1);
+
+                         
+                        int index87_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred36_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index87_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 87, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA86 extends DFA {
+
+        public DFA86(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 86;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_46;
+            this.max = dfa_47;
+            this.accept = dfa_48;
+            this.special = dfa_49;
+            this.transition = dfa_50;
+        }
+        public String getDescription() {
+            return "4886:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_featureCallArguments_8_0= ruleXShortClosure ) ) | ( ( (lv_featureCallArguments_9_0= ruleXExpression ) ) (otherlv_10= ',' ( (lv_featureCallArguments_11_0= ruleXExpression ) ) )* ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA86_0 = input.LA(1);
+
+                         
+                        int index86_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA86_0==RULE_ID) ) {s = 1;}
+
+                        else if ( (LA86_0==20) ) {s = 2;}
+
+                        else if ( (LA86_0==45) && (synpred37_InternalOXtype())) {s = 3;}
+
+                        else if ( (LA86_0==62) && (synpred37_InternalOXtype())) {s = 4;}
+
+                        else if ( ((LA86_0>=RULE_STRING && LA86_0<=RULE_DECIMAL)||(LA86_0>=13 && LA86_0<=15)||(LA86_0>=24 && LA86_0<=25)||LA86_0==32||(LA86_0>=48 && LA86_0<=49)||LA86_0==53||LA86_0==60||LA86_0==63||LA86_0==65||(LA86_0>=69 && LA86_0<=71)||(LA86_0>=74 && LA86_0<=83)||LA86_0==85) ) {s = 5;}
+
+                        else if ( (LA86_0==22) ) {s = 35;}
+
+                         
+                        input.seek(index86_0);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA86_1 = input.LA(1);
+
+                         
+                        int index86_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred37_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index86_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA86_2 = input.LA(1);
+
+                         
+                        int index86_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred37_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index86_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 86, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA88 extends DFA {
+
+        public DFA88(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 88;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_51;
+        }
+        public String getDescription() {
+            return "4984:3: ( ( ( () '[' ) )=> (lv_featureCallArguments_13_0= ruleXClosure ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA88_1 = input.LA(1);
+
+                         
+                        int index88_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred38_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index88_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 88, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String[] dfa_71s = {
+            "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\3\2\1\uffff\10\2\1\1\35\2\1\uffff\30\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[][] dfa_71 = unpackEncodedStringArray(dfa_71s);
+
+    class DFA92 extends DFA {
+
+        public DFA92(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 92;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_71;
+        }
+        public String getDescription() {
+            return "5143:3: ( ( ( '<' )=>otherlv_3= '<' ) ( (lv_typeArguments_4_0= ruleJvmArgumentTypeReference ) ) (otherlv_5= ',' ( (lv_typeArguments_6_0= ruleJvmArgumentTypeReference ) ) )* otherlv_7= '>' )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA92_1 = input.LA(1);
+
+                         
+                        int index92_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred39_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index92_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 92, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA95 extends DFA {
+
+        public DFA95(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 95;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_45;
+        }
+        public String getDescription() {
+            return "5200:3: ( ( ( ( '(' ) )=> (lv_explicitConstructorCall_8_0= '(' ) ) ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )? otherlv_13= ')' )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA95_1 = input.LA(1);
+
+                         
+                        int index95_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred40_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index95_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 95, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA94 extends DFA {
+
+        public DFA94(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 94;
+            this.eot = dfa_8;
+            this.eof = dfa_8;
+            this.min = dfa_46;
+            this.max = dfa_47;
+            this.accept = dfa_48;
+            this.special = dfa_49;
+            this.transition = dfa_50;
+        }
+        public String getDescription() {
+            return "5219:4: ( ( ( ( () ( ( ( ruleJvmFormalParameter ) ) ( ',' ( ( ruleJvmFormalParameter ) ) )* )? ( ( '|' ) ) ) )=> (lv_arguments_9_0= ruleXShortClosure ) ) | ( ( (lv_arguments_10_0= ruleXExpression ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleXExpression ) ) )* ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA94_0 = input.LA(1);
+
+                         
+                        int index94_0 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (LA94_0==RULE_ID) ) {s = 1;}
+
+                        else if ( (LA94_0==20) ) {s = 2;}
+
+                        else if ( (LA94_0==45) && (synpred41_InternalOXtype())) {s = 3;}
+
+                        else if ( (LA94_0==62) && (synpred41_InternalOXtype())) {s = 4;}
+
+                        else if ( ((LA94_0>=RULE_STRING && LA94_0<=RULE_DECIMAL)||(LA94_0>=13 && LA94_0<=15)||(LA94_0>=24 && LA94_0<=25)||LA94_0==32||(LA94_0>=48 && LA94_0<=49)||LA94_0==53||LA94_0==60||LA94_0==63||LA94_0==65||(LA94_0>=69 && LA94_0<=71)||(LA94_0>=74 && LA94_0<=83)||LA94_0==85) ) {s = 5;}
+
+                        else if ( (LA94_0==22) ) {s = 35;}
+
+                         
+                        input.seek(index94_0);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA94_1 = input.LA(1);
+
+                         
+                        int index94_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred41_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index94_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA94_2 = input.LA(1);
+
+                         
+                        int index94_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred41_InternalOXtype()) ) {s = 4;}
+
+                        else if ( (true) ) {s = 5;}
+
+                         
+                        input.seek(index94_2);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 94, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA96 extends DFA {
+
+        public DFA96(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 96;
+            this.eot = dfa_39;
+            this.eof = dfa_40;
+            this.min = dfa_41;
+            this.max = dfa_42;
+            this.accept = dfa_43;
+            this.special = dfa_44;
+            this.transition = dfa_51;
+        }
+        public String getDescription() {
+            return "5317:3: ( ( ( () '[' ) )=> (lv_arguments_14_0= ruleXClosure ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA96_1 = input.LA(1);
+
+                         
+                        int index96_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred42_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index96_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 96, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_72s = "\1\41\115\uffff";
+    static final String dfa_73s = "\1\4\40\0\55\uffff";
+    static final String dfa_74s = "\1\126\40\0\55\uffff";
+    static final String dfa_75s = "\41\uffff\1\2\53\uffff\1\1";
+    static final String dfa_76s = "\1\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\1\7\1\10\1\11\1\12\1\13\1\14\1\15\1\16\1\17\1\20\1\21\1\22\1\23\1\24\1\25\1\26\1\27\1\30\1\31\1\32\1\33\1\34\1\35\1\36\1\37\55\uffff}>";
+    static final String[] dfa_77s = {
+            "\1\27\1\23\1\24\1\25\1\1\4\uffff\1\4\1\3\1\5\1\41\1\uffff\1\41\1\uffff\1\40\2\41\1\uffff\1\17\1\20\6\41\1\15\17\41\1\10\1\7\3\41\1\6\6\41\1\12\1\41\1\uffff\1\31\1\41\1\13\3\41\1\32\1\33\1\34\2\41\1\2\1\16\1\11\1\21\1\22\1\26\1\30\1\35\1\36\1\37\1\41\1\14\1\41",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+    static final short[] dfa_72 = DFA.unpackEncodedString(dfa_72s);
+    static final char[] dfa_73 = DFA.unpackEncodedStringToUnsignedChars(dfa_73s);
+    static final char[] dfa_74 = DFA.unpackEncodedStringToUnsignedChars(dfa_74s);
+    static final short[] dfa_75 = DFA.unpackEncodedString(dfa_75s);
+    static final short[] dfa_76 = DFA.unpackEncodedString(dfa_76s);
+    static final short[][] dfa_77 = unpackEncodedStringArray(dfa_77s);
+
+    class DFA99 extends DFA {
+
+        public DFA99(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 99;
+            this.eot = dfa_39;
+            this.eof = dfa_72;
+            this.min = dfa_73;
+            this.max = dfa_74;
+            this.accept = dfa_75;
+            this.special = dfa_76;
+            this.transition = dfa_77;
+        }
+        public String getDescription() {
+            return "5660:3: ( ( 'extends' | 'static' | 'import' | 'extension' | '!' | '-' | '+' | 'new' | '{' | 'switch' | 'synchronized' | '<' | 'super' | '#' | '[' | 'false' | 'true' | 'null' | 'typeof' | 'if' | 'for' | 'while' | 'do' | 'throw' | 'return' | 'try' | '(' | RULE_ID | RULE_HEX | RULE_INT | RULE_DECIMAL | RULE_STRING )=> (lv_expression_2_0= ruleXExpression ) )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA99_1 = input.LA(1);
+
+                         
+                        int index99_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_1);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 1 : 
+                        int LA99_2 = input.LA(1);
+
+                         
+                        int index99_2 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_2);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 2 : 
+                        int LA99_3 = input.LA(1);
+
+                         
+                        int index99_3 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_3);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 3 : 
+                        int LA99_4 = input.LA(1);
+
+                         
+                        int index99_4 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_4);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 4 : 
+                        int LA99_5 = input.LA(1);
+
+                         
+                        int index99_5 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_5);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 5 : 
+                        int LA99_6 = input.LA(1);
+
+                         
+                        int index99_6 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_6);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 6 : 
+                        int LA99_7 = input.LA(1);
+
+                         
+                        int index99_7 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_7);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 7 : 
+                        int LA99_8 = input.LA(1);
+
+                         
+                        int index99_8 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_8);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 8 : 
+                        int LA99_9 = input.LA(1);
+
+                         
+                        int index99_9 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_9);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 9 : 
+                        int LA99_10 = input.LA(1);
+
+                         
+                        int index99_10 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_10);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 10 : 
+                        int LA99_11 = input.LA(1);
+
+                         
+                        int index99_11 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_11);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 11 : 
+                        int LA99_12 = input.LA(1);
+
+                         
+                        int index99_12 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_12);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 12 : 
+                        int LA99_13 = input.LA(1);
+
+                         
+                        int index99_13 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_13);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 13 : 
+                        int LA99_14 = input.LA(1);
+
+                         
+                        int index99_14 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_14);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 14 : 
+                        int LA99_15 = input.LA(1);
+
+                         
+                        int index99_15 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_15);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 15 : 
+                        int LA99_16 = input.LA(1);
+
+                         
+                        int index99_16 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_16);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 16 : 
+                        int LA99_17 = input.LA(1);
+
+                         
+                        int index99_17 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_17);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 17 : 
+                        int LA99_18 = input.LA(1);
+
+                         
+                        int index99_18 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_18);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 18 : 
+                        int LA99_19 = input.LA(1);
+
+                         
+                        int index99_19 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_19);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 19 : 
+                        int LA99_20 = input.LA(1);
+
+                         
+                        int index99_20 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_20);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 20 : 
+                        int LA99_21 = input.LA(1);
+
+                         
+                        int index99_21 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_21);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 21 : 
+                        int LA99_22 = input.LA(1);
+
+                         
+                        int index99_22 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_22);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 22 : 
+                        int LA99_23 = input.LA(1);
+
+                         
+                        int index99_23 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_23);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 23 : 
+                        int LA99_24 = input.LA(1);
+
+                         
+                        int index99_24 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_24);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 24 : 
+                        int LA99_25 = input.LA(1);
+
+                         
+                        int index99_25 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_25);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 25 : 
+                        int LA99_26 = input.LA(1);
+
+                         
+                        int index99_26 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_26);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 26 : 
+                        int LA99_27 = input.LA(1);
+
+                         
+                        int index99_27 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_27);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 27 : 
+                        int LA99_28 = input.LA(1);
+
+                         
+                        int index99_28 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_28);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 28 : 
+                        int LA99_29 = input.LA(1);
+
+                         
+                        int index99_29 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_29);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 29 : 
+                        int LA99_30 = input.LA(1);
+
+                         
+                        int index99_30 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_30);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 30 : 
+                        int LA99_31 = input.LA(1);
+
+                         
+                        int index99_31 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_31);
+                        if ( s>=0 ) return s;
+                        break;
+                    case 31 : 
+                        int LA99_32 = input.LA(1);
+
+                         
+                        int index99_32 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred43_InternalOXtype()) ) {s = 77;}
+
+                        else if ( (true) ) {s = 33;}
+
+                         
+                        input.seek(index99_32);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 99, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+    static final String dfa_78s = "\117\uffff";
+    static final String dfa_79s = "\1\2\116\uffff";
+    static final String dfa_80s = "\1\4\1\0\115\uffff";
+    static final String dfa_81s = "\1\130\1\0\115\uffff";
+    static final String dfa_82s = "\2\uffff\1\2\113\uffff\1\1";
+    static final String dfa_83s = "\1\uffff\1\0\115\uffff}>";
+    static final String[] dfa_84s = {
+            "\5\2\4\uffff\4\2\1\uffff\1\2\1\uffff\3\2\1\uffff\10\2\1\1\35\2\1\uffff\30\2\1\uffff\1\2",
+            "\1\uffff",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            "",
+            ""
+    };
+
+    static final short[] dfa_78 = DFA.unpackEncodedString(dfa_78s);
+    static final short[] dfa_79 = DFA.unpackEncodedString(dfa_79s);
+    static final char[] dfa_80 = DFA.unpackEncodedStringToUnsignedChars(dfa_80s);
+    static final char[] dfa_81 = DFA.unpackEncodedStringToUnsignedChars(dfa_81s);
+    static final short[] dfa_82 = DFA.unpackEncodedString(dfa_82s);
+    static final short[] dfa_83 = DFA.unpackEncodedString(dfa_83s);
+    static final short[][] dfa_84 = unpackEncodedStringArray(dfa_84s);
+
+    class DFA117 extends DFA {
+
+        public DFA117(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 117;
+            this.eot = dfa_78;
+            this.eof = dfa_79;
+            this.min = dfa_80;
+            this.max = dfa_81;
+            this.accept = dfa_82;
+            this.special = dfa_83;
+            this.transition = dfa_84;
+        }
+        public String getDescription() {
+            return "6318:3: ( ( ( '<' )=>otherlv_1= '<' ) ( (lv_arguments_2_0= ruleJvmArgumentTypeReference ) ) (otherlv_3= ',' ( (lv_arguments_4_0= ruleJvmArgumentTypeReference ) ) )* otherlv_5= '>' ( ( ( ( () '.' ) )=> ( () otherlv_7= '.' ) ) ( ( ruleValidID ) ) ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )? )* )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA117_1 = input.LA(1);
+
+                         
+                        int index117_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred50_InternalOXtype()) ) {s = 78;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index117_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 117, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+
+    class DFA115 extends DFA {
+
+        public DFA115(BaseRecognizer recognizer) {
+            this.recognizer = recognizer;
+            this.decisionNumber = 115;
+            this.eot = dfa_78;
+            this.eof = dfa_79;
+            this.min = dfa_80;
+            this.max = dfa_81;
+            this.accept = dfa_82;
+            this.special = dfa_83;
+            this.transition = dfa_84;
+        }
+        public String getDescription() {
+            return "6412:5: ( ( ( '<' )=>otherlv_9= '<' ) ( (lv_arguments_10_0= ruleJvmArgumentTypeReference ) ) (otherlv_11= ',' ( (lv_arguments_12_0= ruleJvmArgumentTypeReference ) ) )* otherlv_13= '>' )?";
+        }
+        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
+            TokenStream input = (TokenStream)_input;
+        	int _s = s;
+            switch ( s ) {
+                    case 0 : 
+                        int LA115_1 = input.LA(1);
+
+                         
+                        int index115_1 = input.index();
+                        input.rewind();
+                        s = -1;
+                        if ( (synpred52_InternalOXtype()) ) {s = 78;}
+
+                        else if ( (true) ) {s = 2;}
+
+                         
+                        input.seek(index115_1);
+                        if ( s>=0 ) return s;
+                        break;
+            }
+            if (state.backtracking>0) {state.failed=true; return -1;}
+            NoViableAltException nvae =
+                new NoViableAltException(getDescription(), 115, _s, input);
+            error(nvae);
+            throw nvae;
+        }
+    }
+ 
+
+    public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
+    public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
+    public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000024100L});
+    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000008100L});
+    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000010100L});
+    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000040002L});
+    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000100L});
+    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000100002L});
+    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x902300010358E1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000600000L});
+    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000400000L});
+    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000800000L});
+    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x902300010318E1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000002000000L});
+    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x902300010718E1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000004200000L});
+    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000200002L});
+    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x00000003F8000002L});
+    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000100000000L});
+    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000600000000L});
+    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000400000000L});
+    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000800000002L});
+    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000001000000002L});
+    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x000001E000000002L});
+    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000020700000002L});
+    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000200000100100L});
+    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000FC0300000002L});
+    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000100000000000L});
+    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000200000000L});
+    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000200100000000L});
+    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0003000000000002L});
+    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x001C000000010002L});
+    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0040000000000002L});
+    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0180000000000002L});
+    public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0E00000000000002L});
+    public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x000000000000E100L,0x0000000000000400L});
+    public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x000000010000E100L,0x0000000000000C00L});
+    public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000200000100100L,0x0000000000800000L});
+    public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000200200000L});
+    public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0E00000002100002L});
+    public static final BitSet FOLLOW_41 = new BitSet(new long[]{0xD02320010358E1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0E00000002000002L});
+    public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x1000000000000000L});
+    public static final BitSet FOLLOW_44 = new BitSet(new long[]{0xB02300010318E1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x2000000000200000L});
+    public static final BitSet FOLLOW_46 = new BitSet(new long[]{0xD02320010718E1F0L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x4000000000200000L});
+    public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x902300010718E1F0L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000004000000L});
+    public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x90230001031CE1F2L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x902300010318E1F2L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000100000L});
+    public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000001L});
+    public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x902320010318E1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
+    public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x2000200000300100L,0x000000000000001CL});
+    public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x2000000000000000L});
+    public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000014L});
+    public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000200000L,0x0000000000000004L});
+    public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x90230001031CE1F0L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000240000L});
+    public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x902300010318E1F0L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x90230001031CE1F0L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000000040000L});
+    public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
+    public static final BitSet FOLLOW_66 = new BitSet(new long[]{0xB02300010318E1F0L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_67 = new BitSet(new long[]{0xB0230001031CE1F0L,0x00000000002FFFE2L});
+    public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x0000000000800002L});
+    public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000002100002L});
+    public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000002000002L});
+    public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000102100002L});
+    public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x0000000002400000L});
+    public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x902300010318E1F2L,0x00000000002FFCE2L});
+    public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x0000000000000000L,0x0000000000500000L});
+    public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x0000000000000002L,0x0000000000500000L});
+    public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0200000000000002L});
+    public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x00000000000000C0L});
+    public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x0000200000500100L});
+    public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x0000200000000000L});
+    public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x0000000100000002L});
+    public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0200000100000002L});
+    public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000C00L});
+    public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000002L,0x0000000001000000L});
+    public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x0200000000000000L});
+    public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000000010000L});
+    public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000102L});
+
+}
+\ No newline at end of file
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/scoping/AbstractOXtypeScopeProvider.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/scoping/AbstractOXtypeScopeProvider.java
new file mode 100644
index 0000000..7015760
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/scoping/AbstractOXtypeScopeProvider.java
@@ -0,0 +1,9 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.scoping;
+
+import org.eclipse.xtext.xbase.annotations.typesystem.XbaseWithAnnotationsBatchScopeProvider;
+
+public abstract class AbstractOXtypeScopeProvider extends XbaseWithAnnotationsBatchScopeProvider {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSemanticSequencer.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSemanticSequencer.java
new file mode 100644
index 0000000..267bfd5
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSemanticSequencer.java
@@ -0,0 +1,402 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.serializer;
+
+import com.google.inject.Inject;
+import java.util.Set;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Parameter;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.common.types.JvmFormalParameter;
+import org.eclipse.xtext.common.types.JvmGenericArrayTypeReference;
+import org.eclipse.xtext.common.types.JvmInnerTypeReference;
+import org.eclipse.xtext.common.types.JvmLowerBound;
+import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
+import org.eclipse.xtext.common.types.JvmTypeParameter;
+import org.eclipse.xtext.common.types.JvmUpperBound;
+import org.eclipse.xtext.common.types.JvmWildcardTypeReference;
+import org.eclipse.xtext.common.types.TypesPackage;
+import org.eclipse.xtext.serializer.ISerializationContext;
+import org.eclipse.xtext.xbase.XAssignment;
+import org.eclipse.xtext.xbase.XBasicForLoopExpression;
+import org.eclipse.xtext.xbase.XBinaryOperation;
+import org.eclipse.xtext.xbase.XBlockExpression;
+import org.eclipse.xtext.xbase.XBooleanLiteral;
+import org.eclipse.xtext.xbase.XCasePart;
+import org.eclipse.xtext.xbase.XCastedExpression;
+import org.eclipse.xtext.xbase.XCatchClause;
+import org.eclipse.xtext.xbase.XClosure;
+import org.eclipse.xtext.xbase.XConstructorCall;
+import org.eclipse.xtext.xbase.XDoWhileExpression;
+import org.eclipse.xtext.xbase.XFeatureCall;
+import org.eclipse.xtext.xbase.XForLoopExpression;
+import org.eclipse.xtext.xbase.XIfExpression;
+import org.eclipse.xtext.xbase.XInstanceOfExpression;
+import org.eclipse.xtext.xbase.XListLiteral;
+import org.eclipse.xtext.xbase.XMemberFeatureCall;
+import org.eclipse.xtext.xbase.XNullLiteral;
+import org.eclipse.xtext.xbase.XNumberLiteral;
+import org.eclipse.xtext.xbase.XPostfixOperation;
+import org.eclipse.xtext.xbase.XReturnExpression;
+import org.eclipse.xtext.xbase.XSetLiteral;
+import org.eclipse.xtext.xbase.XStringLiteral;
+import org.eclipse.xtext.xbase.XSwitchExpression;
+import org.eclipse.xtext.xbase.XSynchronizedExpression;
+import org.eclipse.xtext.xbase.XThrowExpression;
+import org.eclipse.xtext.xbase.XTryCatchFinallyExpression;
+import org.eclipse.xtext.xbase.XTypeLiteral;
+import org.eclipse.xtext.xbase.XUnaryOperation;
+import org.eclipse.xtext.xbase.XVariableDeclaration;
+import org.eclipse.xtext.xbase.XWhileExpression;
+import org.eclipse.xtext.xbase.XbasePackage;
+import org.eclipse.xtext.xbase.annotations.serializer.XbaseWithAnnotationsSemanticSequencer;
+import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotation;
+import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationElementValuePair;
+import org.eclipse.xtext.xbase.annotations.xAnnotations.XAnnotationsPackage;
+import org.eclipse.xtext.xtype.XFunctionTypeRef;
+import org.eclipse.xtext.xtype.XImportSection;
+import org.eclipse.xtext.xtype.XtypePackage;
+
+@SuppressWarnings("all")
+public class OXtypeSemanticSequencer extends XbaseWithAnnotationsSemanticSequencer {
+
+	@Inject
+	private OXtypeGrammarAccess grammarAccess;
+	
+	@Override
+	public void sequence(ISerializationContext context, EObject semanticObject) {
+		EPackage epackage = semanticObject.eClass().getEPackage();
+		ParserRule rule = context.getParserRule();
+		Action action = context.getAssignedAction();
+		Set<Parameter> parameters = context.getEnabledBooleanParameters();
+		if (epackage == OXtypePackage.eINSTANCE)
+			switch (semanticObject.eClass().getClassifierID()) {
+			case OXtypePackage.OX_IMPORT_DECLARATION:
+				sequence_XImportDeclaration(context, (OXImportDeclaration) semanticObject); 
+				return; 
+			}
+		else if (epackage == TypesPackage.eINSTANCE)
+			switch (semanticObject.eClass().getClassifierID()) {
+			case TypesPackage.JVM_FORMAL_PARAMETER:
+				if (rule == grammarAccess.getFullJvmFormalParameterRule()) {
+					sequence_FullJvmFormalParameter(context, (JvmFormalParameter) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getJvmFormalParameterRule()) {
+					sequence_JvmFormalParameter(context, (JvmFormalParameter) semanticObject); 
+					return; 
+				}
+				else break;
+			case TypesPackage.JVM_GENERIC_ARRAY_TYPE_REFERENCE:
+				sequence_JvmTypeReference(context, (JvmGenericArrayTypeReference) semanticObject); 
+				return; 
+			case TypesPackage.JVM_INNER_TYPE_REFERENCE:
+				sequence_JvmParameterizedTypeReference(context, (JvmInnerTypeReference) semanticObject); 
+				return; 
+			case TypesPackage.JVM_LOWER_BOUND:
+				if (rule == grammarAccess.getJvmLowerBoundAndedRule()) {
+					sequence_JvmLowerBoundAnded(context, (JvmLowerBound) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getJvmLowerBoundRule()) {
+					sequence_JvmLowerBound(context, (JvmLowerBound) semanticObject); 
+					return; 
+				}
+				else break;
+			case TypesPackage.JVM_PARAMETERIZED_TYPE_REFERENCE:
+				if (action == grammarAccess.getJvmParameterizedTypeReferenceAccess().getJvmInnerTypeReferenceOuterAction_1_4_0_0_0()) {
+					sequence_JvmParameterizedTypeReference_JvmInnerTypeReference_1_4_0_0_0(context, (JvmParameterizedTypeReference) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getJvmTypeReferenceRule()
+						|| action == grammarAccess.getJvmTypeReferenceAccess().getJvmGenericArrayTypeReferenceComponentTypeAction_0_1_0_0()
+						|| rule == grammarAccess.getJvmParameterizedTypeReferenceRule()
+						|| rule == grammarAccess.getJvmArgumentTypeReferenceRule()) {
+					sequence_JvmParameterizedTypeReference(context, (JvmParameterizedTypeReference) semanticObject); 
+					return; 
+				}
+				else break;
+			case TypesPackage.JVM_TYPE_PARAMETER:
+				sequence_JvmTypeParameter(context, (JvmTypeParameter) semanticObject); 
+				return; 
+			case TypesPackage.JVM_UPPER_BOUND:
+				if (rule == grammarAccess.getJvmUpperBoundAndedRule()) {
+					sequence_JvmUpperBoundAnded(context, (JvmUpperBound) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getJvmUpperBoundRule()) {
+					sequence_JvmUpperBound(context, (JvmUpperBound) semanticObject); 
+					return; 
+				}
+				else break;
+			case TypesPackage.JVM_WILDCARD_TYPE_REFERENCE:
+				sequence_JvmWildcardTypeReference(context, (JvmWildcardTypeReference) semanticObject); 
+				return; 
+			}
+		else if (epackage == XAnnotationsPackage.eINSTANCE)
+			switch (semanticObject.eClass().getClassifierID()) {
+			case XAnnotationsPackage.XANNOTATION:
+				sequence_XAnnotation(context, (XAnnotation) semanticObject); 
+				return; 
+			case XAnnotationsPackage.XANNOTATION_ELEMENT_VALUE_PAIR:
+				sequence_XAnnotationElementValuePair(context, (XAnnotationElementValuePair) semanticObject); 
+				return; 
+			}
+		else if (epackage == XbasePackage.eINSTANCE)
+			switch (semanticObject.eClass().getClassifierID()) {
+			case XbasePackage.XASSIGNMENT:
+				sequence_XAssignment_XMemberFeatureCall(context, (XAssignment) semanticObject); 
+				return; 
+			case XbasePackage.XBASIC_FOR_LOOP_EXPRESSION:
+				sequence_XBasicForLoopExpression(context, (XBasicForLoopExpression) semanticObject); 
+				return; 
+			case XbasePackage.XBINARY_OPERATION:
+				sequence_XAdditiveExpression_XAndExpression_XAssignment_XEqualityExpression_XMultiplicativeExpression_XOrExpression_XOtherOperatorExpression_XRelationalExpression(context, (XBinaryOperation) semanticObject); 
+				return; 
+			case XbasePackage.XBLOCK_EXPRESSION:
+				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
+						|| action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
+						|| rule == grammarAccess.getXAnnotationElementValueRule()
+						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
+						|| rule == grammarAccess.getXExpressionRule()
+						|| rule == grammarAccess.getXAssignmentRule()
+						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXOrExpressionRule()
+						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXAndExpressionRule()
+						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXEqualityExpressionRule()
+						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXRelationalExpressionRule()
+						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
+						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
+						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXAdditiveExpressionRule()
+						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
+						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXUnaryOperationRule()
+						|| rule == grammarAccess.getXCastedExpressionRule()
+						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
+						|| rule == grammarAccess.getXPostfixOperationRule()
+						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
+						|| rule == grammarAccess.getXMemberFeatureCallRule()
+						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
+						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXPrimaryExpressionRule()
+						|| rule == grammarAccess.getXParenthesizedExpressionRule()
+						|| rule == grammarAccess.getXBlockExpressionRule()
+						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
+					sequence_XBlockExpression(context, (XBlockExpression) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getXExpressionInClosureRule()) {
+					sequence_XExpressionInClosure(context, (XBlockExpression) semanticObject); 
+					return; 
+				}
+				else break;
+			case XbasePackage.XBOOLEAN_LITERAL:
+				sequence_XBooleanLiteral(context, (XBooleanLiteral) semanticObject); 
+				return; 
+			case XbasePackage.XCASE_PART:
+				sequence_XCasePart(context, (XCasePart) semanticObject); 
+				return; 
+			case XbasePackage.XCASTED_EXPRESSION:
+				sequence_XCastedExpression(context, (XCastedExpression) semanticObject); 
+				return; 
+			case XbasePackage.XCATCH_CLAUSE:
+				sequence_XCatchClause(context, (XCatchClause) semanticObject); 
+				return; 
+			case XbasePackage.XCLOSURE:
+				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()
+						|| action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
+						|| rule == grammarAccess.getXAnnotationElementValueRule()
+						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
+						|| rule == grammarAccess.getXExpressionRule()
+						|| rule == grammarAccess.getXAssignmentRule()
+						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXOrExpressionRule()
+						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXAndExpressionRule()
+						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXEqualityExpressionRule()
+						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXRelationalExpressionRule()
+						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
+						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
+						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXAdditiveExpressionRule()
+						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
+						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXUnaryOperationRule()
+						|| rule == grammarAccess.getXCastedExpressionRule()
+						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
+						|| rule == grammarAccess.getXPostfixOperationRule()
+						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
+						|| rule == grammarAccess.getXMemberFeatureCallRule()
+						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
+						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXPrimaryExpressionRule()
+						|| rule == grammarAccess.getXLiteralRule()
+						|| rule == grammarAccess.getXClosureRule()
+						|| rule == grammarAccess.getXParenthesizedExpressionRule()
+						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
+					sequence_XClosure(context, (XClosure) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getXShortClosureRule()) {
+					sequence_XShortClosure(context, (XClosure) semanticObject); 
+					return; 
+				}
+				else break;
+			case XbasePackage.XCONSTRUCTOR_CALL:
+				sequence_XConstructorCall(context, (XConstructorCall) semanticObject); 
+				return; 
+			case XbasePackage.XDO_WHILE_EXPRESSION:
+				sequence_XDoWhileExpression(context, (XDoWhileExpression) semanticObject); 
+				return; 
+			case XbasePackage.XFEATURE_CALL:
+				sequence_XFeatureCall(context, (XFeatureCall) semanticObject); 
+				return; 
+			case XbasePackage.XFOR_LOOP_EXPRESSION:
+				sequence_XForLoopExpression(context, (XForLoopExpression) semanticObject); 
+				return; 
+			case XbasePackage.XIF_EXPRESSION:
+				sequence_XIfExpression(context, (XIfExpression) semanticObject); 
+				return; 
+			case XbasePackage.XINSTANCE_OF_EXPRESSION:
+				sequence_XRelationalExpression(context, (XInstanceOfExpression) semanticObject); 
+				return; 
+			case XbasePackage.XLIST_LITERAL:
+				if (rule == grammarAccess.getXAnnotationElementValueOrCommaListRule()) {
+					sequence_XAnnotationElementValueOrCommaList_XListLiteral(context, (XListLiteral) semanticObject); 
+					return; 
+				}
+				else if (rule == grammarAccess.getXAnnotationElementValueRule()) {
+					sequence_XAnnotationElementValue_XListLiteral(context, (XListLiteral) semanticObject); 
+					return; 
+				}
+				else if (action == grammarAccess.getXAnnotationElementValueOrCommaListAccess().getXListLiteralElementsAction_1_1_0()
+						|| rule == grammarAccess.getXAnnotationOrExpressionRule()
+						|| rule == grammarAccess.getXExpressionRule()
+						|| rule == grammarAccess.getXAssignmentRule()
+						|| action == grammarAccess.getXAssignmentAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXOrExpressionRule()
+						|| action == grammarAccess.getXOrExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXAndExpressionRule()
+						|| action == grammarAccess.getXAndExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXEqualityExpressionRule()
+						|| action == grammarAccess.getXEqualityExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXRelationalExpressionRule()
+						|| action == grammarAccess.getXRelationalExpressionAccess().getXInstanceOfExpressionExpressionAction_1_0_0_0_0()
+						|| action == grammarAccess.getXRelationalExpressionAccess().getXBinaryOperationLeftOperandAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXOtherOperatorExpressionRule()
+						|| action == grammarAccess.getXOtherOperatorExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXAdditiveExpressionRule()
+						|| action == grammarAccess.getXAdditiveExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXMultiplicativeExpressionRule()
+						|| action == grammarAccess.getXMultiplicativeExpressionAccess().getXBinaryOperationLeftOperandAction_1_0_0_0()
+						|| rule == grammarAccess.getXUnaryOperationRule()
+						|| rule == grammarAccess.getXCastedExpressionRule()
+						|| action == grammarAccess.getXCastedExpressionAccess().getXCastedExpressionTargetAction_1_0_0_0()
+						|| rule == grammarAccess.getXPostfixOperationRule()
+						|| action == grammarAccess.getXPostfixOperationAccess().getXPostfixOperationOperandAction_1_0_0()
+						|| rule == grammarAccess.getXMemberFeatureCallRule()
+						|| action == grammarAccess.getXMemberFeatureCallAccess().getXAssignmentAssignableAction_1_0_0_0_0()
+						|| action == grammarAccess.getXMemberFeatureCallAccess().getXMemberFeatureCallMemberCallTargetAction_1_1_0_0_0()
+						|| rule == grammarAccess.getXPrimaryExpressionRule()
+						|| rule == grammarAccess.getXLiteralRule()
+						|| rule == grammarAccess.getXCollectionLiteralRule()
+						|| rule == grammarAccess.getXListLiteralRule()
+						|| rule == grammarAccess.getXParenthesizedExpressionRule()
+						|| rule == grammarAccess.getXExpressionOrVarDeclarationRule()) {
+					sequence_XListLiteral(context, (XListLiteral) semanticObject); 
+					return; 
+				}
+				else break;
+			case XbasePackage.XMEMBER_FEATURE_CALL:
+				sequence_XMemberFeatureCall(context, (XMemberFeatureCall) semanticObject); 
+				return; 
+			case XbasePackage.XNULL_LITERAL:
+				sequence_XNullLiteral(context, (XNullLiteral) semanticObject); 
+				return; 
+			case XbasePackage.XNUMBER_LITERAL:
+				sequence_XNumberLiteral(context, (XNumberLiteral) semanticObject); 
+				return; 
+			case XbasePackage.XPOSTFIX_OPERATION:
+				sequence_XPostfixOperation(context, (XPostfixOperation) semanticObject); 
+				return; 
+			case XbasePackage.XRETURN_EXPRESSION:
+				sequence_XReturnExpression(context, (XReturnExpression) semanticObject); 
+				return; 
+			case XbasePackage.XSET_LITERAL:
+				sequence_XSetLiteral(context, (XSetLiteral) semanticObject); 
+				return; 
+			case XbasePackage.XSTRING_LITERAL:
+				sequence_XStringLiteral(context, (XStringLiteral) semanticObject); 
+				return; 
+			case XbasePackage.XSWITCH_EXPRESSION:
+				sequence_XSwitchExpression(context, (XSwitchExpression) semanticObject); 
+				return; 
+			case XbasePackage.XSYNCHRONIZED_EXPRESSION:
+				sequence_XSynchronizedExpression(context, (XSynchronizedExpression) semanticObject); 
+				return; 
+			case XbasePackage.XTHROW_EXPRESSION:
+				sequence_XThrowExpression(context, (XThrowExpression) semanticObject); 
+				return; 
+			case XbasePackage.XTRY_CATCH_FINALLY_EXPRESSION:
+				sequence_XTryCatchFinallyExpression(context, (XTryCatchFinallyExpression) semanticObject); 
+				return; 
+			case XbasePackage.XTYPE_LITERAL:
+				sequence_XTypeLiteral(context, (XTypeLiteral) semanticObject); 
+				return; 
+			case XbasePackage.XUNARY_OPERATION:
+				sequence_XUnaryOperation(context, (XUnaryOperation) semanticObject); 
+				return; 
+			case XbasePackage.XVARIABLE_DECLARATION:
+				sequence_XVariableDeclaration(context, (XVariableDeclaration) semanticObject); 
+				return; 
+			case XbasePackage.XWHILE_EXPRESSION:
+				sequence_XWhileExpression(context, (XWhileExpression) semanticObject); 
+				return; 
+			}
+		else if (epackage == XtypePackage.eINSTANCE)
+			switch (semanticObject.eClass().getClassifierID()) {
+			case XtypePackage.XFUNCTION_TYPE_REF:
+				sequence_XFunctionTypeRef(context, (XFunctionTypeRef) semanticObject); 
+				return; 
+			case XtypePackage.XIMPORT_SECTION:
+				sequence_XImportSection(context, (XImportSection) semanticObject); 
+				return; 
+			}
+		if (errorAcceptor != null)
+			errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
+	}
+	
+	/**
+	 * Contexts:
+	 *     XImportDeclaration returns OXImportDeclaration
+	 *
+	 * Constraint:
+	 *     (
+	 *         (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID)) | 
+	 *         importedType=[JvmDeclaredType|QualifiedName] | 
+	 *         importedNamespace=QualifiedNameWithWildcard | 
+	 *         (fqnImport?='ns' importedFullyQualifiedName=QualifiedName)
+	 *     )
+	 */
+	protected void sequence_XImportDeclaration(ISerializationContext context, OXImportDeclaration semanticObject) {
+		genericSequencer.createSequence(context, semanticObject);
+	}
+	
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSyntacticSequencer.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSyntacticSequencer.java
new file mode 100644
index 0000000..b9ad555
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/serializer/OXtypeSyntacticSequencer.java
@@ -0,0 +1,265 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.serializer;
+
+import com.google.inject.Inject;
+import java.util.List;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.osbp.xtext.oxtype.services.OXtypeGrammarAccess;
+import org.eclipse.xtext.IGrammarAccess;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.AbstractElementAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.GroupAlias;
+import org.eclipse.xtext.serializer.analysis.GrammarAlias.TokenAlias;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynNavigable;
+import org.eclipse.xtext.serializer.analysis.ISyntacticSequencerPDAProvider.ISynTransition;
+import org.eclipse.xtext.serializer.sequencer.AbstractSyntacticSequencer;
+
+@SuppressWarnings("all")
+public class OXtypeSyntacticSequencer extends AbstractSyntacticSequencer {
+
+	protected OXtypeGrammarAccess grammarAccess;
+	protected AbstractElementAlias match_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q;
+	protected AbstractElementAlias match_XBlockExpression_SemicolonKeyword_2_1_q;
+	protected AbstractElementAlias match_XExpressionInClosure_SemicolonKeyword_1_1_q;
+	protected AbstractElementAlias match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q;
+	protected AbstractElementAlias match_XImportDeclaration_SemicolonKeyword_3_q;
+	protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_a;
+	protected AbstractElementAlias match_XParenthesizedExpression_LeftParenthesisKeyword_0_p;
+	
+	@Inject
+	protected void init(IGrammarAccess access) {
+		grammarAccess = (OXtypeGrammarAccess) access;
+		match_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXAnnotationAccess().getLeftParenthesisKeyword_3_0()), new TokenAlias(false, false, grammarAccess.getXAnnotationAccess().getRightParenthesisKeyword_3_2()));
+		match_XBlockExpression_SemicolonKeyword_2_1_q = new TokenAlias(false, true, grammarAccess.getXBlockExpressionAccess().getSemicolonKeyword_2_1());
+		match_XExpressionInClosure_SemicolonKeyword_1_1_q = new TokenAlias(false, true, grammarAccess.getXExpressionInClosureAccess().getSemicolonKeyword_1_1());
+		match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q = new GroupAlias(false, true, new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getLeftParenthesisKeyword_0_0()), new TokenAlias(false, false, grammarAccess.getXFunctionTypeRefAccess().getRightParenthesisKeyword_0_2()));
+		match_XImportDeclaration_SemicolonKeyword_3_q = new TokenAlias(false, true, grammarAccess.getXImportDeclarationAccess().getSemicolonKeyword_3());
+		match_XParenthesizedExpression_LeftParenthesisKeyword_0_a = new TokenAlias(true, true, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+		match_XParenthesizedExpression_LeftParenthesisKeyword_0_p = new TokenAlias(true, false, grammarAccess.getXParenthesizedExpressionAccess().getLeftParenthesisKeyword_0());
+	}
+	
+	@Override
+	protected String getUnassignedRuleCallToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+		if (ruleCall.getRule() == grammarAccess.getArrayBracketsRule())
+			return getArrayBracketsToken(semanticObject, ruleCall, node);
+		else if (ruleCall.getRule() == grammarAccess.getOpSingleAssignRule())
+			return getOpSingleAssignToken(semanticObject, ruleCall, node);
+		return "";
+	}
+	
+	/**
+	 * ArrayBrackets :
+	 * 	'[' ']'
+	 * ;
+	 */
+	protected String getArrayBracketsToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+		if (node != null)
+			return getTokenText(node);
+		return "[]";
+	}
+	
+	/**
+	 * OpSingleAssign:
+	 * 	'='
+	 * ;
+	 */
+	protected String getOpSingleAssignToken(EObject semanticObject, RuleCall ruleCall, INode node) {
+		if (node != null)
+			return getTokenText(node);
+		return "=";
+	}
+	
+	@Override
+	protected void emitUnassignedTokens(EObject semanticObject, ISynTransition transition, INode fromNode, INode toNode) {
+		if (transition.getAmbiguousSyntaxes().isEmpty()) return;
+		List<INode> transitionNodes = collectNodes(fromNode, toNode);
+		for (AbstractElementAlias syntax : transition.getAmbiguousSyntaxes()) {
+			List<INode> syntaxNodes = getNodesFor(transitionNodes, syntax);
+			if (match_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q.equals(syntax))
+				emit_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_XBlockExpression_SemicolonKeyword_2_1_q.equals(syntax))
+				emit_XBlockExpression_SemicolonKeyword_2_1_q(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_XExpressionInClosure_SemicolonKeyword_1_1_q.equals(syntax))
+				emit_XExpressionInClosure_SemicolonKeyword_1_1_q(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q.equals(syntax))
+				emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_XImportDeclaration_SemicolonKeyword_3_q.equals(syntax))
+				emit_XImportDeclaration_SemicolonKeyword_3_q(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_a.equals(syntax))
+				emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(semanticObject, getLastNavigableState(), syntaxNodes);
+			else if (match_XParenthesizedExpression_LeftParenthesisKeyword_0_p.equals(syntax))
+				emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(semanticObject, getLastNavigableState(), syntaxNodes);
+			else acceptNodes(getLastNavigableState(), syntaxNodes);
+		}
+	}
+
+	/**
+	 * Ambiguous syntax:
+	 *     ('(' ')')?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     annotationType=[JvmAnnotationType|QualifiedName] (ambiguity) (rule end)
+	 */
+	protected void emit_XAnnotation___LeftParenthesisKeyword_3_0_RightParenthesisKeyword_3_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' ')' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) '}' (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 */
+	protected void emit_XBlockExpression_SemicolonKeyword_2_1_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) (rule end)
+	 *     expressions+=XExpressionOrVarDeclaration (ambiguity) expressions+=XExpressionOrVarDeclaration
+	 */
+	protected void emit_XExpressionInClosure_SemicolonKeyword_1_1_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
+	 *     ('(' ')')?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '=>' returnType=JvmTypeReference
+	 */
+	protected void emit_XFunctionTypeRef___LeftParenthesisKeyword_0_0_RightParenthesisKeyword_0_2__q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
+	 *     ';'?
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     importedFullyQualifiedName=QualifiedName (ambiguity) (rule end)
+	 *     importedNamespace=QualifiedNameWithWildcard (ambiguity) (rule end)
+	 *     importedType=[JvmDeclaredType|QualifiedName] (ambiguity) (rule end)
+	 *     memberName=ValidID (ambiguity) (rule end)
+	 *     wildcard?='*' (ambiguity) (rule end)
+	 */
+	protected void emit_XImportDeclaration_SemicolonKeyword_3_q(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
+	 *     '('*
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' (rule start)
+	 *     (rule start) (ambiguity) 'return' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 */
+	protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_a(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+	/**
+	 * Ambiguous syntax:
+	 *     '('+
+	 *
+	 * This ambiguous syntax occurs at:
+	 *     (rule start) (ambiguity) '#' '[' ']' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '[' elements+=XExpression
+	 *     (rule start) (ambiguity) '#' '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '#' '{' elements+=XExpression
+	 *     (rule start) (ambiguity) '<' typeArguments+=JvmArgumentTypeReference
+	 *     (rule start) (ambiguity) '[' declaredFormalParameters+=JvmFormalParameter
+	 *     (rule start) (ambiguity) '[' explicitSyntax?='|'
+	 *     (rule start) (ambiguity) '[' expression=XExpressionInClosure
+	 *     (rule start) (ambiguity) 'do' body=XExpression
+	 *     (rule start) (ambiguity) 'false' ')' (rule start)
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' ')' eachExpression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' ';' updateExpressions+=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' ';' expression=XExpression
+	 *     (rule start) (ambiguity) 'for' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'for' '(' initExpressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) 'if' '(' if=XExpression
+	 *     (rule start) (ambiguity) 'new' constructor=[JvmConstructor|QualifiedName]
+	 *     (rule start) (ambiguity) 'null' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' ')' (rule start)
+	 *     (rule start) (ambiguity) 'return' expression=XExpression
+	 *     (rule start) (ambiguity) 'switch' '(' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' declaredParam=JvmFormalParameter
+	 *     (rule start) (ambiguity) 'switch' switch=XExpression
+	 *     (rule start) (ambiguity) 'synchronized' '(' param=XExpression
+	 *     (rule start) (ambiguity) 'throw' expression=XExpression
+	 *     (rule start) (ambiguity) 'try' expression=XExpression
+	 *     (rule start) (ambiguity) 'typeof' '(' type=[JvmType|QualifiedName]
+	 *     (rule start) (ambiguity) 'while' '(' predicate=XExpression
+	 *     (rule start) (ambiguity) '{' '}' ')' (rule start)
+	 *     (rule start) (ambiguity) '{' expressions+=XExpressionOrVarDeclaration
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|FeatureCallID]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|IdOrSuper]
+	 *     (rule start) (ambiguity) feature=[JvmIdentifiableElement|OpUnary]
+	 *     (rule start) (ambiguity) isTrue?='true'
+	 *     (rule start) (ambiguity) value=Number
+	 *     (rule start) (ambiguity) value=STRING
+	 *     (rule start) (ambiguity) {XAssignment.assignable=}
+	 *     (rule start) (ambiguity) {XBinaryOperation.leftOperand=}
+	 *     (rule start) (ambiguity) {XCastedExpression.target=}
+	 *     (rule start) (ambiguity) {XInstanceOfExpression.expression=}
+	 *     (rule start) (ambiguity) {XMemberFeatureCall.memberCallTarget=}
+	 *     (rule start) (ambiguity) {XPostfixOperation.operand=}
+	 */
+	protected void emit_XParenthesizedExpression_LeftParenthesisKeyword_0_p(EObject semanticObject, ISynNavigable transition, List<INode> nodes) {
+		acceptNodes(transition, nodes);
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/services/OXtypeGrammarAccess.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/services/OXtypeGrammarAccess.java
new file mode 100644
index 0000000..e3057d1
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/services/OXtypeGrammarAccess.java
@@ -0,0 +1,1184 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.services;
+
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import java.util.List;
+import org.eclipse.xtext.Action;
+import org.eclipse.xtext.Alternatives;
+import org.eclipse.xtext.Assignment;
+import org.eclipse.xtext.CrossReference;
+import org.eclipse.xtext.Grammar;
+import org.eclipse.xtext.GrammarUtil;
+import org.eclipse.xtext.Group;
+import org.eclipse.xtext.Keyword;
+import org.eclipse.xtext.ParserRule;
+import org.eclipse.xtext.RuleCall;
+import org.eclipse.xtext.TerminalRule;
+import org.eclipse.xtext.service.AbstractElementFinder.AbstractGrammarElementFinder;
+import org.eclipse.xtext.service.GrammarProvider;
+import org.eclipse.xtext.xbase.annotations.services.XbaseWithAnnotationsGrammarAccess;
+import org.eclipse.xtext.xbase.services.XbaseGrammarAccess;
+import org.eclipse.xtext.xbase.services.XtypeGrammarAccess;
+
+@Singleton
+public class OXtypeGrammarAccess extends AbstractGrammarElementFinder {
+	
+	public class XImportDeclarationElements extends AbstractParserRuleElementFinder {
+		private final ParserRule rule = (ParserRule) GrammarUtil.findRuleForName(getGrammar(), "org.eclipse.osbp.xtext.oxtype.OXtype.XImportDeclaration");
+		private final Group cGroup = (Group)rule.eContents().get(1);
+		private final Action cOXImportDeclarationAction_0 = (Action)cGroup.eContents().get(0);
+		private final Keyword cImportKeyword_1 = (Keyword)cGroup.eContents().get(1);
+		private final Alternatives cAlternatives_2 = (Alternatives)cGroup.eContents().get(2);
+		private final Group cGroup_2_0 = (Group)cAlternatives_2.eContents().get(0);
+		private final Assignment cStaticAssignment_2_0_0 = (Assignment)cGroup_2_0.eContents().get(0);
+		private final Keyword cStaticStaticKeyword_2_0_0_0 = (Keyword)cStaticAssignment_2_0_0.eContents().get(0);
+		private final Assignment cExtensionAssignment_2_0_1 = (Assignment)cGroup_2_0.eContents().get(1);
+		private final Keyword cExtensionExtensionKeyword_2_0_1_0 = (Keyword)cExtensionAssignment_2_0_1.eContents().get(0);
+		private final Assignment cImportedTypeAssignment_2_0_2 = (Assignment)cGroup_2_0.eContents().get(2);
+		private final CrossReference cImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0 = (CrossReference)cImportedTypeAssignment_2_0_2.eContents().get(0);
+		private final RuleCall cImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1 = (RuleCall)cImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0.eContents().get(1);
+		private final Alternatives cAlternatives_2_0_3 = (Alternatives)cGroup_2_0.eContents().get(3);
+		private final Assignment cWildcardAssignment_2_0_3_0 = (Assignment)cAlternatives_2_0_3.eContents().get(0);
+		private final Keyword cWildcardAsteriskKeyword_2_0_3_0_0 = (Keyword)cWildcardAssignment_2_0_3_0.eContents().get(0);
+		private final Assignment cMemberNameAssignment_2_0_3_1 = (Assignment)cAlternatives_2_0_3.eContents().get(1);
+		private final RuleCall cMemberNameValidIDParserRuleCall_2_0_3_1_0 = (RuleCall)cMemberNameAssignment_2_0_3_1.eContents().get(0);
+		private final Assignment cImportedTypeAssignment_2_1 = (Assignment)cAlternatives_2.eContents().get(1);
+		private final CrossReference cImportedTypeJvmDeclaredTypeCrossReference_2_1_0 = (CrossReference)cImportedTypeAssignment_2_1.eContents().get(0);
+		private final RuleCall cImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1 = (RuleCall)cImportedTypeJvmDeclaredTypeCrossReference_2_1_0.eContents().get(1);
+		private final Assignment cImportedNamespaceAssignment_2_2 = (Assignment)cAlternatives_2.eContents().get(2);
+		private final RuleCall cImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0 = (RuleCall)cImportedNamespaceAssignment_2_2.eContents().get(0);
+		private final Group cGroup_2_3 = (Group)cAlternatives_2.eContents().get(3);
+		private final Assignment cFqnImportAssignment_2_3_0 = (Assignment)cGroup_2_3.eContents().get(0);
+		private final Keyword cFqnImportNsKeyword_2_3_0_0 = (Keyword)cFqnImportAssignment_2_3_0.eContents().get(0);
+		private final Assignment cImportedFullyQualifiedNameAssignment_2_3_1 = (Assignment)cGroup_2_3.eContents().get(1);
+		private final RuleCall cImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0 = (RuleCall)cImportedFullyQualifiedNameAssignment_2_3_1.eContents().get(0);
+		private final Keyword cSemicolonKeyword_3 = (Keyword)cGroup.eContents().get(3);
+		
+		//@ Override XImportDeclaration OXImportDeclaration:
+		//	{OXImportDeclaration}
+		//	'import' (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
+		//	(wildcard?='*' | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] |
+		//	importedNamespace=QualifiedNameWithWildcard
+		//	| fqnImport?='ns' importedFullyQualifiedName=QualifiedName) ';'?;
+		@Override public ParserRule getRule() { return rule; }
+		
+		//{OXImportDeclaration} 'import' (static?='static' extension?='extension'?
+		//importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID) |
+		//importedType=[JvmDeclaredType|QualifiedName] | importedNamespace=QualifiedNameWithWildcard | fqnImport?='ns'
+		//importedFullyQualifiedName=QualifiedName) ';'?
+		public Group getGroup() { return cGroup; }
+		
+		//{OXImportDeclaration}
+		public Action getOXImportDeclarationAction_0() { return cOXImportDeclarationAction_0; }
+		
+		//'import'
+		public Keyword getImportKeyword_1() { return cImportKeyword_1; }
+		
+		//static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' |
+		//memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] | importedNamespace=QualifiedNameWithWildcard |
+		//fqnImport?='ns' importedFullyQualifiedName=QualifiedName
+		public Alternatives getAlternatives_2() { return cAlternatives_2; }
+		
+		//static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' |
+		//memberName=ValidID)
+		public Group getGroup_2_0() { return cGroup_2_0; }
+		
+		//static?='static'
+		public Assignment getStaticAssignment_2_0_0() { return cStaticAssignment_2_0_0; }
+		
+		//'static'
+		public Keyword getStaticStaticKeyword_2_0_0_0() { return cStaticStaticKeyword_2_0_0_0; }
+		
+		//extension?='extension'?
+		public Assignment getExtensionAssignment_2_0_1() { return cExtensionAssignment_2_0_1; }
+		
+		//'extension'
+		public Keyword getExtensionExtensionKeyword_2_0_1_0() { return cExtensionExtensionKeyword_2_0_1_0; }
+		
+		//importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
+		public Assignment getImportedTypeAssignment_2_0_2() { return cImportedTypeAssignment_2_0_2; }
+		
+		//[JvmDeclaredType|QualifiedNameInStaticImport]
+		public CrossReference getImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0() { return cImportedTypeJvmDeclaredTypeCrossReference_2_0_2_0; }
+		
+		//QualifiedNameInStaticImport
+		public RuleCall getImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1() { return cImportedTypeJvmDeclaredTypeQualifiedNameInStaticImportParserRuleCall_2_0_2_0_1; }
+		
+		//wildcard?='*' | memberName=ValidID
+		public Alternatives getAlternatives_2_0_3() { return cAlternatives_2_0_3; }
+		
+		//wildcard?='*'
+		public Assignment getWildcardAssignment_2_0_3_0() { return cWildcardAssignment_2_0_3_0; }
+		
+		//'*'
+		public Keyword getWildcardAsteriskKeyword_2_0_3_0_0() { return cWildcardAsteriskKeyword_2_0_3_0_0; }
+		
+		//memberName=ValidID
+		public Assignment getMemberNameAssignment_2_0_3_1() { return cMemberNameAssignment_2_0_3_1; }
+		
+		//ValidID
+		public RuleCall getMemberNameValidIDParserRuleCall_2_0_3_1_0() { return cMemberNameValidIDParserRuleCall_2_0_3_1_0; }
+		
+		//importedType=[JvmDeclaredType|QualifiedName]
+		public Assignment getImportedTypeAssignment_2_1() { return cImportedTypeAssignment_2_1; }
+		
+		//[JvmDeclaredType|QualifiedName]
+		public CrossReference getImportedTypeJvmDeclaredTypeCrossReference_2_1_0() { return cImportedTypeJvmDeclaredTypeCrossReference_2_1_0; }
+		
+		//QualifiedName
+		public RuleCall getImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1() { return cImportedTypeJvmDeclaredTypeQualifiedNameParserRuleCall_2_1_0_1; }
+		
+		//importedNamespace=QualifiedNameWithWildcard
+		public Assignment getImportedNamespaceAssignment_2_2() { return cImportedNamespaceAssignment_2_2; }
+		
+		//QualifiedNameWithWildcard
+		public RuleCall getImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0() { return cImportedNamespaceQualifiedNameWithWildcardParserRuleCall_2_2_0; }
+		
+		//fqnImport?='ns' importedFullyQualifiedName=QualifiedName
+		public Group getGroup_2_3() { return cGroup_2_3; }
+		
+		//fqnImport?='ns'
+		public Assignment getFqnImportAssignment_2_3_0() { return cFqnImportAssignment_2_3_0; }
+		
+		//'ns'
+		public Keyword getFqnImportNsKeyword_2_3_0_0() { return cFqnImportNsKeyword_2_3_0_0; }
+		
+		//importedFullyQualifiedName=QualifiedName
+		public Assignment getImportedFullyQualifiedNameAssignment_2_3_1() { return cImportedFullyQualifiedNameAssignment_2_3_1; }
+		
+		//QualifiedName
+		public RuleCall getImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0() { return cImportedFullyQualifiedNameQualifiedNameParserRuleCall_2_3_1_0; }
+		
+		//';'?
+		public Keyword getSemicolonKeyword_3() { return cSemicolonKeyword_3; }
+	}
+	
+	
+	private final XImportDeclarationElements pXImportDeclaration;
+	
+	private final Grammar grammar;
+	
+	private final XbaseWithAnnotationsGrammarAccess gaXbaseWithAnnotations;
+	
+	private final XbaseGrammarAccess gaXbase;
+	
+	private final XtypeGrammarAccess gaXtype;
+
+	@Inject
+	public OXtypeGrammarAccess(GrammarProvider grammarProvider,
+			XbaseWithAnnotationsGrammarAccess gaXbaseWithAnnotations,
+			XbaseGrammarAccess gaXbase,
+			XtypeGrammarAccess gaXtype) {
+		this.grammar = internalFindGrammar(grammarProvider);
+		this.gaXbaseWithAnnotations = gaXbaseWithAnnotations;
+		this.gaXbase = gaXbase;
+		this.gaXtype = gaXtype;
+		this.pXImportDeclaration = new XImportDeclarationElements();
+	}
+	
+	protected Grammar internalFindGrammar(GrammarProvider grammarProvider) {
+		Grammar grammar = grammarProvider.getGrammar(this);
+		while (grammar != null) {
+			if ("org.eclipse.osbp.xtext.oxtype.OXtype".equals(grammar.getName())) {
+				return grammar;
+			}
+			List<Grammar> grammars = grammar.getUsedGrammars();
+			if (!grammars.isEmpty()) {
+				grammar = grammars.iterator().next();
+			} else {
+				return null;
+			}
+		}
+		return grammar;
+	}
+	
+	@Override
+	public Grammar getGrammar() {
+		return grammar;
+	}
+	
+	
+	public XbaseWithAnnotationsGrammarAccess getXbaseWithAnnotationsGrammarAccess() {
+		return gaXbaseWithAnnotations;
+	}
+	
+	public XbaseGrammarAccess getXbaseGrammarAccess() {
+		return gaXbase;
+	}
+	
+	public XtypeGrammarAccess getXtypeGrammarAccess() {
+		return gaXtype;
+	}
+
+	
+	//@ Override XImportDeclaration OXImportDeclaration:
+	//	{OXImportDeclaration}
+	//	'import' (static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport]
+	//	(wildcard?='*' | memberName=ValidID) | importedType=[JvmDeclaredType|QualifiedName] |
+	//	importedNamespace=QualifiedNameWithWildcard
+	//	| fqnImport?='ns' importedFullyQualifiedName=QualifiedName) ';'?;
+	public XImportDeclarationElements getXImportDeclarationAccess() {
+		return pXImportDeclaration;
+	}
+	
+	public ParserRule getXImportDeclarationRule() {
+		return getXImportDeclarationAccess().getRule();
+	}
+	
+	//XAnnotation:
+	//	{XAnnotation}
+	//	'@' annotationType=[types::JvmAnnotationType|QualifiedName] (=> '(' (elementValuePairs+=XAnnotationElementValuePair
+	//	(',' elementValuePairs+=XAnnotationElementValuePair)*
+	//	| value=XAnnotationElementValueOrCommaList)?
+	//	')')?;
+	public XbaseWithAnnotationsGrammarAccess.XAnnotationElements getXAnnotationAccess() {
+		return gaXbaseWithAnnotations.getXAnnotationAccess();
+	}
+	
+	public ParserRule getXAnnotationRule() {
+		return getXAnnotationAccess().getRule();
+	}
+	
+	//XAnnotationElementValuePair:
+	//	=> (element=[types::JvmOperation|ValidID] '=') value=XAnnotationElementValue;
+	public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValuePairElements getXAnnotationElementValuePairAccess() {
+		return gaXbaseWithAnnotations.getXAnnotationElementValuePairAccess();
+	}
+	
+	public ParserRule getXAnnotationElementValuePairRule() {
+		return getXAnnotationElementValuePairAccess().getRule();
+	}
+	
+	//XAnnotationElementValueOrCommaList xbase::XExpression:
+	//	=> ({xbase::XListLiteral} '#' '[') (elements+=XAnnotationOrExpression (',' elements+=XAnnotationOrExpression)*)? ']'
+	//	| XAnnotationOrExpression ({xbase::XListLiteral.elements+=current} (',' elements+=XAnnotationOrExpression)+)?;
+	public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValueOrCommaListElements getXAnnotationElementValueOrCommaListAccess() {
+		return gaXbaseWithAnnotations.getXAnnotationElementValueOrCommaListAccess();
+	}
+	
+	public ParserRule getXAnnotationElementValueOrCommaListRule() {
+		return getXAnnotationElementValueOrCommaListAccess().getRule();
+	}
+	
+	//XAnnotationElementValue xbase::XExpression:
+	//	=> ({xbase::XListLiteral} '#' '[') (elements+=XAnnotationOrExpression (',' elements+=XAnnotationOrExpression)*)? ']'
+	//	| XAnnotationOrExpression;
+	public XbaseWithAnnotationsGrammarAccess.XAnnotationElementValueElements getXAnnotationElementValueAccess() {
+		return gaXbaseWithAnnotations.getXAnnotationElementValueAccess();
+	}
+	
+	public ParserRule getXAnnotationElementValueRule() {
+		return getXAnnotationElementValueAccess().getRule();
+	}
+	
+	//XAnnotationOrExpression xbase::XExpression:
+	//	XAnnotation | XExpression;
+	public XbaseWithAnnotationsGrammarAccess.XAnnotationOrExpressionElements getXAnnotationOrExpressionAccess() {
+		return gaXbaseWithAnnotations.getXAnnotationOrExpressionAccess();
+	}
+	
+	public ParserRule getXAnnotationOrExpressionRule() {
+		return getXAnnotationOrExpressionAccess().getRule();
+	}
+	
+	//XExpression:
+	//	XAssignment;
+	public XbaseGrammarAccess.XExpressionElements getXExpressionAccess() {
+		return gaXbase.getXExpressionAccess();
+	}
+	
+	public ParserRule getXExpressionRule() {
+		return getXExpressionAccess().getRule();
+	}
+	
+	//XAssignment XExpression:
+	//	{XAssignment} feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign value=XAssignment | XOrExpression
+	//	(=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMultiAssign])
+	//	rightOperand=XAssignment)?;
+	public XbaseGrammarAccess.XAssignmentElements getXAssignmentAccess() {
+		return gaXbase.getXAssignmentAccess();
+	}
+	
+	public ParserRule getXAssignmentRule() {
+		return getXAssignmentAccess().getRule();
+	}
+	
+	//OpSingleAssign:
+	//	'=';
+	public XbaseGrammarAccess.OpSingleAssignElements getOpSingleAssignAccess() {
+		return gaXbase.getOpSingleAssignAccess();
+	}
+	
+	public ParserRule getOpSingleAssignRule() {
+		return getOpSingleAssignAccess().getRule();
+	}
+	
+	//OpMultiAssign:
+	//	'+=' | '-=' | '*=' | '/=' | '%=' |
+	//	'<' '<' '=' |
+	//	'>' '>'? '>=';
+	public XbaseGrammarAccess.OpMultiAssignElements getOpMultiAssignAccess() {
+		return gaXbase.getOpMultiAssignAccess();
+	}
+	
+	public ParserRule getOpMultiAssignRule() {
+		return getOpMultiAssignAccess().getRule();
+	}
+	
+	//XOrExpression XExpression:
+	//	XAndExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOr])
+	//	rightOperand=XAndExpression)*;
+	public XbaseGrammarAccess.XOrExpressionElements getXOrExpressionAccess() {
+		return gaXbase.getXOrExpressionAccess();
+	}
+	
+	public ParserRule getXOrExpressionRule() {
+		return getXOrExpressionAccess().getRule();
+	}
+	
+	//OpOr:
+	//	'||';
+	public XbaseGrammarAccess.OpOrElements getOpOrAccess() {
+		return gaXbase.getOpOrAccess();
+	}
+	
+	public ParserRule getOpOrRule() {
+		return getOpOrAccess().getRule();
+	}
+	
+	//XAndExpression XExpression:
+	//	XEqualityExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAnd])
+	//	rightOperand=XEqualityExpression)*;
+	public XbaseGrammarAccess.XAndExpressionElements getXAndExpressionAccess() {
+		return gaXbase.getXAndExpressionAccess();
+	}
+	
+	public ParserRule getXAndExpressionRule() {
+		return getXAndExpressionAccess().getRule();
+	}
+	
+	//OpAnd:
+	//	'&&';
+	public XbaseGrammarAccess.OpAndElements getOpAndAccess() {
+		return gaXbase.getOpAndAccess();
+	}
+	
+	public ParserRule getOpAndRule() {
+		return getOpAndAccess().getRule();
+	}
+	
+	//XEqualityExpression XExpression:
+	//	XRelationalExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpEquality])
+	//	rightOperand=XRelationalExpression)*;
+	public XbaseGrammarAccess.XEqualityExpressionElements getXEqualityExpressionAccess() {
+		return gaXbase.getXEqualityExpressionAccess();
+	}
+	
+	public ParserRule getXEqualityExpressionRule() {
+		return getXEqualityExpressionAccess().getRule();
+	}
+	
+	//OpEquality:
+	//	'==' | '!=' | '===' | '!==';
+	public XbaseGrammarAccess.OpEqualityElements getOpEqualityAccess() {
+		return gaXbase.getOpEqualityAccess();
+	}
+	
+	public ParserRule getOpEqualityRule() {
+		return getOpEqualityAccess().getRule();
+	}
+	
+	//XRelationalExpression XExpression:
+	//	XOtherOperatorExpression (=> ({XInstanceOfExpression.expression=current} 'instanceof') type=JvmTypeReference |
+	//	=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpCompare])
+	//	rightOperand=XOtherOperatorExpression)*;
+	public XbaseGrammarAccess.XRelationalExpressionElements getXRelationalExpressionAccess() {
+		return gaXbase.getXRelationalExpressionAccess();
+	}
+	
+	public ParserRule getXRelationalExpressionRule() {
+		return getXRelationalExpressionAccess().getRule();
+	}
+	
+	//OpCompare:
+	//	'>=' | '<' '=' | '>' | '<';
+	public XbaseGrammarAccess.OpCompareElements getOpCompareAccess() {
+		return gaXbase.getOpCompareAccess();
+	}
+	
+	public ParserRule getOpCompareRule() {
+		return getOpCompareAccess().getRule();
+	}
+	
+	//XOtherOperatorExpression XExpression:
+	//	XAdditiveExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpOther])
+	//	rightOperand=XAdditiveExpression)*;
+	public XbaseGrammarAccess.XOtherOperatorExpressionElements getXOtherOperatorExpressionAccess() {
+		return gaXbase.getXOtherOperatorExpressionAccess();
+	}
+	
+	public ParserRule getXOtherOperatorExpressionRule() {
+		return getXOtherOperatorExpressionAccess().getRule();
+	}
+	
+	//OpOther:
+	//	'->'
+	//	| '..<'
+	//	| '>' '..'
+	//	| '..'
+	//	| '=>'
+	//	| '>' (=> ('>' '>') | '>') | '<' (=> ('<' '<') | '<' | '=>') | '<>'
+	//	| '?:';
+	public XbaseGrammarAccess.OpOtherElements getOpOtherAccess() {
+		return gaXbase.getOpOtherAccess();
+	}
+	
+	public ParserRule getOpOtherRule() {
+		return getOpOtherAccess().getRule();
+	}
+	
+	//XAdditiveExpression XExpression:
+	//	XMultiplicativeExpression (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpAdd])
+	//	rightOperand=XMultiplicativeExpression)*;
+	public XbaseGrammarAccess.XAdditiveExpressionElements getXAdditiveExpressionAccess() {
+		return gaXbase.getXAdditiveExpressionAccess();
+	}
+	
+	public ParserRule getXAdditiveExpressionRule() {
+		return getXAdditiveExpressionAccess().getRule();
+	}
+	
+	//OpAdd:
+	//	'+' | '-';
+	public XbaseGrammarAccess.OpAddElements getOpAddAccess() {
+		return gaXbase.getOpAddAccess();
+	}
+	
+	public ParserRule getOpAddRule() {
+		return getOpAddAccess().getRule();
+	}
+	
+	//XMultiplicativeExpression XExpression:
+	//	XUnaryOperation (=> ({XBinaryOperation.leftOperand=current} feature=[types::JvmIdentifiableElement|OpMulti])
+	//	rightOperand=XUnaryOperation)*;
+	public XbaseGrammarAccess.XMultiplicativeExpressionElements getXMultiplicativeExpressionAccess() {
+		return gaXbase.getXMultiplicativeExpressionAccess();
+	}
+	
+	public ParserRule getXMultiplicativeExpressionRule() {
+		return getXMultiplicativeExpressionAccess().getRule();
+	}
+	
+	//OpMulti:
+	//	'*' | '**' | '/' | '%';
+	public XbaseGrammarAccess.OpMultiElements getOpMultiAccess() {
+		return gaXbase.getOpMultiAccess();
+	}
+	
+	public ParserRule getOpMultiRule() {
+		return getOpMultiAccess().getRule();
+	}
+	
+	//XUnaryOperation XExpression:
+	//	{XUnaryOperation} feature=[types::JvmIdentifiableElement|OpUnary] operand=XUnaryOperation
+	//	| XCastedExpression;
+	public XbaseGrammarAccess.XUnaryOperationElements getXUnaryOperationAccess() {
+		return gaXbase.getXUnaryOperationAccess();
+	}
+	
+	public ParserRule getXUnaryOperationRule() {
+		return getXUnaryOperationAccess().getRule();
+	}
+	
+	//OpUnary:
+	//	"!" | "-" | "+";
+	public XbaseGrammarAccess.OpUnaryElements getOpUnaryAccess() {
+		return gaXbase.getOpUnaryAccess();
+	}
+	
+	public ParserRule getOpUnaryRule() {
+		return getOpUnaryAccess().getRule();
+	}
+	
+	//XCastedExpression XExpression:
+	//	XPostfixOperation (=> ({XCastedExpression.target=current} 'as') type=JvmTypeReference)*;
+	public XbaseGrammarAccess.XCastedExpressionElements getXCastedExpressionAccess() {
+		return gaXbase.getXCastedExpressionAccess();
+	}
+	
+	public ParserRule getXCastedExpressionRule() {
+		return getXCastedExpressionAccess().getRule();
+	}
+	
+	//XPostfixOperation XExpression:
+	//	XMemberFeatureCall => ({XPostfixOperation.operand=current} feature=[types::JvmIdentifiableElement|OpPostfix])?;
+	public XbaseGrammarAccess.XPostfixOperationElements getXPostfixOperationAccess() {
+		return gaXbase.getXPostfixOperationAccess();
+	}
+	
+	public ParserRule getXPostfixOperationRule() {
+		return getXPostfixOperationAccess().getRule();
+	}
+	
+	//OpPostfix:
+	//	"++" | "--";
+	public XbaseGrammarAccess.OpPostfixElements getOpPostfixAccess() {
+		return gaXbase.getOpPostfixAccess();
+	}
+	
+	public ParserRule getOpPostfixRule() {
+		return getOpPostfixAccess().getRule();
+	}
+	
+	//XMemberFeatureCall XExpression:
+	//	XPrimaryExpression (=> ({XAssignment.assignable=current} ('.' | explicitStatic?="::")
+	//	feature=[types::JvmIdentifiableElement|FeatureCallID] OpSingleAssign) value=XAssignment
+	//	| => ({XMemberFeatureCall.memberCallTarget=current} ("." | nullSafe?="?." | explicitStatic?="::")) ('<'
+	//	typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')?
+	//	feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?='(' (memberCallArguments+=XShortClosure
+	//	| memberCallArguments+=XExpression (',' memberCallArguments+=XExpression)*)?
+	//	')')?
+	//	memberCallArguments+=XClosure?)*;
+	public XbaseGrammarAccess.XMemberFeatureCallElements getXMemberFeatureCallAccess() {
+		return gaXbase.getXMemberFeatureCallAccess();
+	}
+	
+	public ParserRule getXMemberFeatureCallRule() {
+		return getXMemberFeatureCallAccess().getRule();
+	}
+	
+	//XPrimaryExpression XExpression:
+	//	XConstructorCall | XBlockExpression | XSwitchExpression | XSynchronizedExpression | XFeatureCall | XLiteral |
+	//	XIfExpression | XForLoopExpression | XBasicForLoopExpression | XWhileExpression | XDoWhileExpression |
+	//	XThrowExpression | XReturnExpression | XTryCatchFinallyExpression | XParenthesizedExpression;
+	public XbaseGrammarAccess.XPrimaryExpressionElements getXPrimaryExpressionAccess() {
+		return gaXbase.getXPrimaryExpressionAccess();
+	}
+	
+	public ParserRule getXPrimaryExpressionRule() {
+		return getXPrimaryExpressionAccess().getRule();
+	}
+	
+	//XLiteral XExpression:
+	//	XCollectionLiteral | XClosure | XBooleanLiteral | XNumberLiteral | XNullLiteral | XStringLiteral | XTypeLiteral;
+	public XbaseGrammarAccess.XLiteralElements getXLiteralAccess() {
+		return gaXbase.getXLiteralAccess();
+	}
+	
+	public ParserRule getXLiteralRule() {
+		return getXLiteralAccess().getRule();
+	}
+	
+	//XCollectionLiteral:
+	//	XSetLiteral | XListLiteral;
+	public XbaseGrammarAccess.XCollectionLiteralElements getXCollectionLiteralAccess() {
+		return gaXbase.getXCollectionLiteralAccess();
+	}
+	
+	public ParserRule getXCollectionLiteralRule() {
+		return getXCollectionLiteralAccess().getRule();
+	}
+	
+	//XSetLiteral:
+	//	{XSetLiteral} '#' '{' (elements+=XExpression (',' elements+=XExpression)*)? '}';
+	public XbaseGrammarAccess.XSetLiteralElements getXSetLiteralAccess() {
+		return gaXbase.getXSetLiteralAccess();
+	}
+	
+	public ParserRule getXSetLiteralRule() {
+		return getXSetLiteralAccess().getRule();
+	}
+	
+	//XListLiteral:
+	//	{XListLiteral} '#' '[' (elements+=XExpression (',' elements+=XExpression)*)? ']';
+	public XbaseGrammarAccess.XListLiteralElements getXListLiteralAccess() {
+		return gaXbase.getXListLiteralAccess();
+	}
+	
+	public ParserRule getXListLiteralRule() {
+		return getXListLiteralAccess().getRule();
+	}
+	
+	//XClosure XExpression:
+	//	=> ({XClosure}
+	//	'[')
+	//	=> ((declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)?
+	//	explicitSyntax?='|')?
+	//	expression=XExpressionInClosure
+	//	']';
+	public XbaseGrammarAccess.XClosureElements getXClosureAccess() {
+		return gaXbase.getXClosureAccess();
+	}
+	
+	public ParserRule getXClosureRule() {
+		return getXClosureAccess().getRule();
+	}
+	
+	//XExpressionInClosure XExpression:
+	//	{XBlockExpression} (expressions+=XExpressionOrVarDeclaration ';'?)*;
+	public XbaseGrammarAccess.XExpressionInClosureElements getXExpressionInClosureAccess() {
+		return gaXbase.getXExpressionInClosureAccess();
+	}
+	
+	public ParserRule getXExpressionInClosureRule() {
+		return getXExpressionInClosureAccess().getRule();
+	}
+	
+	//XShortClosure XExpression:
+	//	=> ({XClosure} (declaredFormalParameters+=JvmFormalParameter (',' declaredFormalParameters+=JvmFormalParameter)*)?
+	//	explicitSyntax?='|') expression=XExpression;
+	public XbaseGrammarAccess.XShortClosureElements getXShortClosureAccess() {
+		return gaXbase.getXShortClosureAccess();
+	}
+	
+	public ParserRule getXShortClosureRule() {
+		return getXShortClosureAccess().getRule();
+	}
+	
+	//XParenthesizedExpression XExpression:
+	//	'(' XExpression ')';
+	public XbaseGrammarAccess.XParenthesizedExpressionElements getXParenthesizedExpressionAccess() {
+		return gaXbase.getXParenthesizedExpressionAccess();
+	}
+	
+	public ParserRule getXParenthesizedExpressionRule() {
+		return getXParenthesizedExpressionAccess().getRule();
+	}
+	
+	//XIfExpression XExpression:
+	//	{XIfExpression}
+	//	'if' '(' if=XExpression ')'
+	//	then=XExpression (=> 'else' else=XExpression)?;
+	public XbaseGrammarAccess.XIfExpressionElements getXIfExpressionAccess() {
+		return gaXbase.getXIfExpressionAccess();
+	}
+	
+	public ParserRule getXIfExpressionRule() {
+		return getXIfExpressionAccess().getRule();
+	}
+	
+	//XSwitchExpression XExpression:
+	//	{XSwitchExpression}
+	//	'switch' (=> ('(' declaredParam=JvmFormalParameter ':') switch=XExpression ')'
+	//	| => (declaredParam=JvmFormalParameter ':')? switch=XExpression) '{'
+	//	cases+=XCasePart* ('default' ':' default=XExpression)?
+	//	'}';
+	public XbaseGrammarAccess.XSwitchExpressionElements getXSwitchExpressionAccess() {
+		return gaXbase.getXSwitchExpressionAccess();
+	}
+	
+	public ParserRule getXSwitchExpressionRule() {
+		return getXSwitchExpressionAccess().getRule();
+	}
+	
+	//XCasePart:
+	//	{XCasePart} typeGuard=JvmTypeReference? ('case' case=XExpression)? (':' then=XExpression | fallThrough?=',');
+	public XbaseGrammarAccess.XCasePartElements getXCasePartAccess() {
+		return gaXbase.getXCasePartAccess();
+	}
+	
+	public ParserRule getXCasePartRule() {
+		return getXCasePartAccess().getRule();
+	}
+	
+	//XForLoopExpression XExpression:
+	//	=> ({XForLoopExpression}
+	//	'for' '(' declaredParam=JvmFormalParameter ':') forExpression=XExpression ')'
+	//	eachExpression=XExpression;
+	public XbaseGrammarAccess.XForLoopExpressionElements getXForLoopExpressionAccess() {
+		return gaXbase.getXForLoopExpressionAccess();
+	}
+	
+	public ParserRule getXForLoopExpressionRule() {
+		return getXForLoopExpressionAccess().getRule();
+	}
+	
+	//XBasicForLoopExpression XExpression:
+	//	{XBasicForLoopExpression}
+	//	'for' '(' (initExpressions+=XExpressionOrVarDeclaration (',' initExpressions+=XExpressionOrVarDeclaration)*)? ';'
+	//	expression=XExpression? ';' (updateExpressions+=XExpression (',' updateExpressions+=XExpression)*)? ')'
+	//	eachExpression=XExpression;
+	public XbaseGrammarAccess.XBasicForLoopExpressionElements getXBasicForLoopExpressionAccess() {
+		return gaXbase.getXBasicForLoopExpressionAccess();
+	}
+	
+	public ParserRule getXBasicForLoopExpressionRule() {
+		return getXBasicForLoopExpressionAccess().getRule();
+	}
+	
+	//XWhileExpression XExpression:
+	//	{XWhileExpression}
+	//	'while' '(' predicate=XExpression ')'
+	//	body=XExpression;
+	public XbaseGrammarAccess.XWhileExpressionElements getXWhileExpressionAccess() {
+		return gaXbase.getXWhileExpressionAccess();
+	}
+	
+	public ParserRule getXWhileExpressionRule() {
+		return getXWhileExpressionAccess().getRule();
+	}
+	
+	//XDoWhileExpression XExpression:
+	//	{XDoWhileExpression}
+	//	'do'
+	//	body=XExpression
+	//	'while' '(' predicate=XExpression ')';
+	public XbaseGrammarAccess.XDoWhileExpressionElements getXDoWhileExpressionAccess() {
+		return gaXbase.getXDoWhileExpressionAccess();
+	}
+	
+	public ParserRule getXDoWhileExpressionRule() {
+		return getXDoWhileExpressionAccess().getRule();
+	}
+	
+	//XBlockExpression XExpression:
+	//	{XBlockExpression}
+	//	'{' (expressions+=XExpressionOrVarDeclaration ';'?)*
+	//	'}';
+	public XbaseGrammarAccess.XBlockExpressionElements getXBlockExpressionAccess() {
+		return gaXbase.getXBlockExpressionAccess();
+	}
+	
+	public ParserRule getXBlockExpressionRule() {
+		return getXBlockExpressionAccess().getRule();
+	}
+	
+	//XExpressionOrVarDeclaration XExpression:
+	//	XVariableDeclaration | XExpression;
+	public XbaseGrammarAccess.XExpressionOrVarDeclarationElements getXExpressionOrVarDeclarationAccess() {
+		return gaXbase.getXExpressionOrVarDeclarationAccess();
+	}
+	
+	public ParserRule getXExpressionOrVarDeclarationRule() {
+		return getXExpressionOrVarDeclarationAccess().getRule();
+	}
+	
+	//XVariableDeclaration XExpression:
+	//	{XVariableDeclaration} (writeable?='var' | 'val') (=> (type=JvmTypeReference name=ValidID) | name=ValidID) ('='
+	//	right=XExpression)?;
+	public XbaseGrammarAccess.XVariableDeclarationElements getXVariableDeclarationAccess() {
+		return gaXbase.getXVariableDeclarationAccess();
+	}
+	
+	public ParserRule getXVariableDeclarationRule() {
+		return getXVariableDeclarationAccess().getRule();
+	}
+	
+	//JvmFormalParameter types::JvmFormalParameter:
+	//	parameterType=JvmTypeReference? name=ValidID;
+	public XbaseGrammarAccess.JvmFormalParameterElements getJvmFormalParameterAccess() {
+		return gaXbase.getJvmFormalParameterAccess();
+	}
+	
+	public ParserRule getJvmFormalParameterRule() {
+		return getJvmFormalParameterAccess().getRule();
+	}
+	
+	//FullJvmFormalParameter types::JvmFormalParameter:
+	//	parameterType=JvmTypeReference name=ValidID;
+	public XbaseGrammarAccess.FullJvmFormalParameterElements getFullJvmFormalParameterAccess() {
+		return gaXbase.getFullJvmFormalParameterAccess();
+	}
+	
+	public ParserRule getFullJvmFormalParameterRule() {
+		return getFullJvmFormalParameterAccess().getRule();
+	}
+	
+	//XFeatureCall XExpression:
+	//	{XFeatureCall} ('<' typeArguments+=JvmArgumentTypeReference (',' typeArguments+=JvmArgumentTypeReference)* '>')?
+	//	feature=[types::JvmIdentifiableElement|IdOrSuper] (=> explicitOperationCall?='(' (featureCallArguments+=XShortClosure
+	//	| featureCallArguments+=XExpression (',' featureCallArguments+=XExpression)*)?
+	//	')')?
+	//	featureCallArguments+=XClosure?;
+	public XbaseGrammarAccess.XFeatureCallElements getXFeatureCallAccess() {
+		return gaXbase.getXFeatureCallAccess();
+	}
+	
+	public ParserRule getXFeatureCallRule() {
+		return getXFeatureCallAccess().getRule();
+	}
+	
+	//FeatureCallID:
+	//	ValidID | 'extends' | 'static' | 'import' | 'extension';
+	public XbaseGrammarAccess.FeatureCallIDElements getFeatureCallIDAccess() {
+		return gaXbase.getFeatureCallIDAccess();
+	}
+	
+	public ParserRule getFeatureCallIDRule() {
+		return getFeatureCallIDAccess().getRule();
+	}
+	
+	//IdOrSuper:
+	//	FeatureCallID | 'super';
+	public XbaseGrammarAccess.IdOrSuperElements getIdOrSuperAccess() {
+		return gaXbase.getIdOrSuperAccess();
+	}
+	
+	public ParserRule getIdOrSuperRule() {
+		return getIdOrSuperAccess().getRule();
+	}
+	
+	//XConstructorCall XExpression:
+	//	{XConstructorCall}
+	//	'new' constructor=[types::JvmConstructor|QualifiedName] (=> '<' typeArguments+=JvmArgumentTypeReference (','
+	//	typeArguments+=JvmArgumentTypeReference)* '>')? (=> explicitConstructorCall?='(' (arguments+=XShortClosure
+	//	| arguments+=XExpression (',' arguments+=XExpression)*)?
+	//	')')?
+	//	arguments+=XClosure?;
+	public XbaseGrammarAccess.XConstructorCallElements getXConstructorCallAccess() {
+		return gaXbase.getXConstructorCallAccess();
+	}
+	
+	public ParserRule getXConstructorCallRule() {
+		return getXConstructorCallAccess().getRule();
+	}
+	
+	//XBooleanLiteral XExpression:
+	//	{XBooleanLiteral} ('false' | isTrue?='true');
+	public XbaseGrammarAccess.XBooleanLiteralElements getXBooleanLiteralAccess() {
+		return gaXbase.getXBooleanLiteralAccess();
+	}
+	
+	public ParserRule getXBooleanLiteralRule() {
+		return getXBooleanLiteralAccess().getRule();
+	}
+	
+	//XNullLiteral XExpression:
+	//	{XNullLiteral} 'null';
+	public XbaseGrammarAccess.XNullLiteralElements getXNullLiteralAccess() {
+		return gaXbase.getXNullLiteralAccess();
+	}
+	
+	public ParserRule getXNullLiteralRule() {
+		return getXNullLiteralAccess().getRule();
+	}
+	
+	//XNumberLiteral XExpression:
+	//	{XNumberLiteral} value=Number;
+	public XbaseGrammarAccess.XNumberLiteralElements getXNumberLiteralAccess() {
+		return gaXbase.getXNumberLiteralAccess();
+	}
+	
+	public ParserRule getXNumberLiteralRule() {
+		return getXNumberLiteralAccess().getRule();
+	}
+	
+	//XStringLiteral XExpression:
+	//	{XStringLiteral} value=STRING;
+	public XbaseGrammarAccess.XStringLiteralElements getXStringLiteralAccess() {
+		return gaXbase.getXStringLiteralAccess();
+	}
+	
+	public ParserRule getXStringLiteralRule() {
+		return getXStringLiteralAccess().getRule();
+	}
+	
+	//XTypeLiteral XExpression:
+	//	{XTypeLiteral} 'typeof' '(' type=[types::JvmType|QualifiedName] arrayDimensions+=ArrayBrackets* ')';
+	public XbaseGrammarAccess.XTypeLiteralElements getXTypeLiteralAccess() {
+		return gaXbase.getXTypeLiteralAccess();
+	}
+	
+	public ParserRule getXTypeLiteralRule() {
+		return getXTypeLiteralAccess().getRule();
+	}
+	
+	//XThrowExpression XExpression:
+	//	{XThrowExpression} 'throw' expression=XExpression;
+	public XbaseGrammarAccess.XThrowExpressionElements getXThrowExpressionAccess() {
+		return gaXbase.getXThrowExpressionAccess();
+	}
+	
+	public ParserRule getXThrowExpressionRule() {
+		return getXThrowExpressionAccess().getRule();
+	}
+	
+	//XReturnExpression XExpression:
+	//	{XReturnExpression} 'return' -> expression=XExpression?;
+	public XbaseGrammarAccess.XReturnExpressionElements getXReturnExpressionAccess() {
+		return gaXbase.getXReturnExpressionAccess();
+	}
+	
+	public ParserRule getXReturnExpressionRule() {
+		return getXReturnExpressionAccess().getRule();
+	}
+	
+	//XTryCatchFinallyExpression XExpression:
+	//	{XTryCatchFinallyExpression}
+	//	'try'
+	//	expression=XExpression (catchClauses+=XCatchClause+ (=> 'finally' finallyExpression=XExpression)?
+	//	| 'finally' finallyExpression=XExpression);
+	public XbaseGrammarAccess.XTryCatchFinallyExpressionElements getXTryCatchFinallyExpressionAccess() {
+		return gaXbase.getXTryCatchFinallyExpressionAccess();
+	}
+	
+	public ParserRule getXTryCatchFinallyExpressionRule() {
+		return getXTryCatchFinallyExpressionAccess().getRule();
+	}
+	
+	//XSynchronizedExpression XExpression:
+	//	=> ({XSynchronizedExpression}
+	//	'synchronized' '(') param=XExpression ')' expression=XExpression;
+	public XbaseGrammarAccess.XSynchronizedExpressionElements getXSynchronizedExpressionAccess() {
+		return gaXbase.getXSynchronizedExpressionAccess();
+	}
+	
+	public ParserRule getXSynchronizedExpressionRule() {
+		return getXSynchronizedExpressionAccess().getRule();
+	}
+	
+	//XCatchClause:
+	//	=> 'catch' '(' declaredParam=FullJvmFormalParameter ')' expression=XExpression;
+	public XbaseGrammarAccess.XCatchClauseElements getXCatchClauseAccess() {
+		return gaXbase.getXCatchClauseAccess();
+	}
+	
+	public ParserRule getXCatchClauseRule() {
+		return getXCatchClauseAccess().getRule();
+	}
+	
+	//QualifiedName:
+	//	ValidID (=> '.' ValidID)*;
+	public XbaseGrammarAccess.QualifiedNameElements getQualifiedNameAccess() {
+		return gaXbase.getQualifiedNameAccess();
+	}
+	
+	public ParserRule getQualifiedNameRule() {
+		return getQualifiedNameAccess().getRule();
+	}
+	
+	//Number hidden():
+	//	HEX | (INT | DECIMAL) ('.' (INT | DECIMAL))?;
+	public XbaseGrammarAccess.NumberElements getNumberAccess() {
+		return gaXbase.getNumberAccess();
+	}
+	
+	public ParserRule getNumberRule() {
+		return getNumberAccess().getRule();
+	}
+	
+	///**
+	// * Dummy rule, for "better" downwards compatibility, since GrammarAccess generates non-static inner classes, 
+	// * which makes downstream grammars break on classloading, when a rule is removed.
+	// */ StaticQualifier:
+	//	(ValidID '::')+;
+	public XbaseGrammarAccess.StaticQualifierElements getStaticQualifierAccess() {
+		return gaXbase.getStaticQualifierAccess();
+	}
+	
+	public ParserRule getStaticQualifierRule() {
+		return getStaticQualifierAccess().getRule();
+	}
+	
+	//terminal HEX:
+	//	('0x' | '0X') ('0'..'9' | 'a'..'f' | 'A'..'F' | '_')+ ('#' (('b' | 'B') ('i' | 'I') | ('l' | 'L')))?;
+	public TerminalRule getHEXRule() {
+		return gaXbase.getHEXRule();
+	}
+	
+	//terminal INT returns ecore::EInt:
+	//	'0'..'9' ('0'..'9' | '_')*;
+	public TerminalRule getINTRule() {
+		return gaXbase.getINTRule();
+	}
+	
+	//terminal DECIMAL:
+	//	INT (('e' | 'E') ('+' | '-')? INT)? (('b' | 'B') ('i' | 'I' | 'd' | 'D') | ('l' | 'L' | 'd' | 'D' | 'f' | 'F'))?;
+	public TerminalRule getDECIMALRule() {
+		return gaXbase.getDECIMALRule();
+	}
+	
+	//JvmTypeReference:
+	//	JvmParameterizedTypeReference => ({JvmGenericArrayTypeReference.componentType=current} ArrayBrackets)*
+	//	| XFunctionTypeRef;
+	public XtypeGrammarAccess.JvmTypeReferenceElements getJvmTypeReferenceAccess() {
+		return gaXtype.getJvmTypeReferenceAccess();
+	}
+	
+	public ParserRule getJvmTypeReferenceRule() {
+		return getJvmTypeReferenceAccess().getRule();
+	}
+	
+	//ArrayBrackets:
+	//	'[' ']';
+	public XtypeGrammarAccess.ArrayBracketsElements getArrayBracketsAccess() {
+		return gaXtype.getArrayBracketsAccess();
+	}
+	
+	public ParserRule getArrayBracketsRule() {
+		return getArrayBracketsAccess().getRule();
+	}
+	
+	//XFunctionTypeRef:
+	//	('(' (paramTypes+=JvmTypeReference (',' paramTypes+=JvmTypeReference)*)? ')')? '=>' returnType=JvmTypeReference;
+	public XtypeGrammarAccess.XFunctionTypeRefElements getXFunctionTypeRefAccess() {
+		return gaXtype.getXFunctionTypeRefAccess();
+	}
+	
+	public ParserRule getXFunctionTypeRefRule() {
+		return getXFunctionTypeRefAccess().getRule();
+	}
+	
+	//JvmParameterizedTypeReference:
+	//	type=[JvmType|super::QualifiedName] (=> '<' arguments+=JvmArgumentTypeReference (','
+	//	arguments+=JvmArgumentTypeReference)* '>' (=> ({JvmInnerTypeReference.outer=current} '.') type=[JvmType|ValidID] (=>
+	//	'<' arguments+=JvmArgumentTypeReference (',' arguments+=JvmArgumentTypeReference)* '>')?)*)?;
+	public XtypeGrammarAccess.JvmParameterizedTypeReferenceElements getJvmParameterizedTypeReferenceAccess() {
+		return gaXtype.getJvmParameterizedTypeReferenceAccess();
+	}
+	
+	public ParserRule getJvmParameterizedTypeReferenceRule() {
+		return getJvmParameterizedTypeReferenceAccess().getRule();
+	}
+	
+	//JvmArgumentTypeReference JvmTypeReference:
+	//	JvmTypeReference | JvmWildcardTypeReference;
+	public XtypeGrammarAccess.JvmArgumentTypeReferenceElements getJvmArgumentTypeReferenceAccess() {
+		return gaXtype.getJvmArgumentTypeReferenceAccess();
+	}
+	
+	public ParserRule getJvmArgumentTypeReferenceRule() {
+		return getJvmArgumentTypeReferenceAccess().getRule();
+	}
+	
+	//JvmWildcardTypeReference:
+	//	{JvmWildcardTypeReference} '?' (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*
+	//	| constraints+=JvmLowerBound constraints+=JvmLowerBoundAnded*)?;
+	public XtypeGrammarAccess.JvmWildcardTypeReferenceElements getJvmWildcardTypeReferenceAccess() {
+		return gaXtype.getJvmWildcardTypeReferenceAccess();
+	}
+	
+	public ParserRule getJvmWildcardTypeReferenceRule() {
+		return getJvmWildcardTypeReferenceAccess().getRule();
+	}
+	
+	//JvmUpperBound:
+	//	'extends' typeReference=JvmTypeReference;
+	public XtypeGrammarAccess.JvmUpperBoundElements getJvmUpperBoundAccess() {
+		return gaXtype.getJvmUpperBoundAccess();
+	}
+	
+	public ParserRule getJvmUpperBoundRule() {
+		return getJvmUpperBoundAccess().getRule();
+	}
+	
+	//JvmUpperBoundAnded JvmUpperBound:
+	//	'&' typeReference=JvmTypeReference;
+	public XtypeGrammarAccess.JvmUpperBoundAndedElements getJvmUpperBoundAndedAccess() {
+		return gaXtype.getJvmUpperBoundAndedAccess();
+	}
+	
+	public ParserRule getJvmUpperBoundAndedRule() {
+		return getJvmUpperBoundAndedAccess().getRule();
+	}
+	
+	//JvmLowerBound:
+	//	'super' typeReference=JvmTypeReference;
+	public XtypeGrammarAccess.JvmLowerBoundElements getJvmLowerBoundAccess() {
+		return gaXtype.getJvmLowerBoundAccess();
+	}
+	
+	public ParserRule getJvmLowerBoundRule() {
+		return getJvmLowerBoundAccess().getRule();
+	}
+	
+	//JvmLowerBoundAnded JvmLowerBound:
+	//	'&' typeReference=JvmTypeReference;
+	public XtypeGrammarAccess.JvmLowerBoundAndedElements getJvmLowerBoundAndedAccess() {
+		return gaXtype.getJvmLowerBoundAndedAccess();
+	}
+	
+	public ParserRule getJvmLowerBoundAndedRule() {
+		return getJvmLowerBoundAndedAccess().getRule();
+	}
+	
+	//JvmTypeParameter:
+	//	name=ValidID (constraints+=JvmUpperBound constraints+=JvmUpperBoundAnded*)?;
+	public XtypeGrammarAccess.JvmTypeParameterElements getJvmTypeParameterAccess() {
+		return gaXtype.getJvmTypeParameterAccess();
+	}
+	
+	public ParserRule getJvmTypeParameterRule() {
+		return getJvmTypeParameterAccess().getRule();
+	}
+	
+	//QualifiedNameWithWildcard:
+	//	super::QualifiedName '.' '*';
+	public XtypeGrammarAccess.QualifiedNameWithWildcardElements getQualifiedNameWithWildcardAccess() {
+		return gaXtype.getQualifiedNameWithWildcardAccess();
+	}
+	
+	public ParserRule getQualifiedNameWithWildcardRule() {
+		return getQualifiedNameWithWildcardAccess().getRule();
+	}
+	
+	//ValidID:
+	//	ID;
+	public XtypeGrammarAccess.ValidIDElements getValidIDAccess() {
+		return gaXtype.getValidIDAccess();
+	}
+	
+	public ParserRule getValidIDRule() {
+		return getValidIDAccess().getRule();
+	}
+	
+	//XImportSection:
+	//	importDeclarations+=super::XImportDeclaration+;
+	public XtypeGrammarAccess.XImportSectionElements getXImportSectionAccess() {
+		return gaXtype.getXImportSectionAccess();
+	}
+	
+	public ParserRule getXImportSectionRule() {
+		return getXImportSectionAccess().getRule();
+	}
+	
+	//QualifiedNameInStaticImport:
+	//	(ValidID '.')+;
+	public XtypeGrammarAccess.QualifiedNameInStaticImportElements getQualifiedNameInStaticImportAccess() {
+		return gaXtype.getQualifiedNameInStaticImportAccess();
+	}
+	
+	public ParserRule getQualifiedNameInStaticImportRule() {
+		return getQualifiedNameInStaticImportAccess().getRule();
+	}
+	
+	//terminal ID:
+	//	'^'? ('a'..'z' | 'A'..'Z' | '$' | '_') ('a'..'z' | 'A'..'Z' | '$' | '_' | '0'..'9')*;
+	public TerminalRule getIDRule() {
+		return gaXtype.getIDRule();
+	}
+	
+	//terminal STRING:
+	//	'"' ('\\' . | !('\\' | '"'))* '"'? |
+	//	"'" ('\\' . | !('\\' | "'"))* "'"?;
+	public TerminalRule getSTRINGRule() {
+		return gaXtype.getSTRINGRule();
+	}
+	
+	//terminal ML_COMMENT:
+	//	'/*'->'*/';
+	public TerminalRule getML_COMMENTRule() {
+		return gaXtype.getML_COMMENTRule();
+	}
+	
+	//terminal SL_COMMENT:
+	//	'//' !('\n' | '\r')* ('\r'? '\n')?;
+	public TerminalRule getSL_COMMENTRule() {
+		return gaXtype.getSL_COMMENTRule();
+	}
+	
+	//terminal WS:
+	//	' ' | '\t' | '\r' | '\n'+;
+	public TerminalRule getWSRule() {
+		return gaXtype.getWSRule();
+	}
+	
+	//terminal ANY_OTHER:
+	//	.;
+	public TerminalRule getANY_OTHERRule() {
+		return gaXtype.getANY_OTHERRule();
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/validation/AbstractOXtypeValidator.java b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/validation/AbstractOXtypeValidator.java
new file mode 100644
index 0000000..58c9c63
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src-gen/org/eclipse/osbp/xtext/oxtype/validation/AbstractOXtypeValidator.java
@@ -0,0 +1,24 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.validation;
+
+import java.util.ArrayList;
+import java.util.List;
+import org.eclipse.emf.ecore.EPackage;
+import org.eclipse.xtext.xbase.annotations.validation.XbaseWithAnnotationsValidator;
+
+public abstract class AbstractOXtypeValidator extends XbaseWithAnnotationsValidator {
+	
+	@Override
+	protected List<EPackage> getEPackages() {
+		List<EPackage> result = new ArrayList<EPackage>(super.getEPackages());
+		result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/osbp/xtext/oxtype/OXtype"));
+		result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/Xtext/Xbase/XAnnotations"));
+		result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xbase"));
+		result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/common/JavaVMTypes"));
+		result.add(EPackage.Registry.INSTANCE.getEPackage("http://www.eclipse.org/xtext/xbase/Xtype"));
+		return result;
+	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2 b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2
new file mode 100644
index 0000000..48f0972
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/GenerateOXtype.mwe2
@@ -0,0 +1,50 @@
+module org.eclipse.osbp.xtext.oxtype.GenerateOXtype
+
+import org.eclipse.xtext.xtext.generator.*
+import org.eclipse.xtext.xtext.generator.model.project.*
+
+var rootPath = ".."
+var runtimeProjectName = "org.eclipse.osbp.xtext.oxtype"
+var projectPath = "${rootPath}/${runtimeProjectName}"
+
+Workflow {
+
+	component = XtextGenerator {
+		configuration = {
+			project = StandardProjectConfig {
+				baseName = "org.eclipse.osbp.xtext.oxtype"
+				rootPath = rootPath
+				runtimeTest = {
+					enabled = true
+				}
+				eclipsePlugin = {
+					enabled = true
+				}
+				eclipsePluginTest = {
+					enabled = true
+				}
+				createEclipseMetaData = true
+			}
+			
+			code = {
+				encoding = "UTF-8"
+				lineDelimiter = "\n"
+				fileHeader = "/*\n * generated by Xtext \${version}\n */"
+			}
+		}
+		language = StandardLanguage {
+			resourceSet = org.eclipse.xtext.resource.XtextResourceSet : resourceSet {}
+			referencedResource = "platform:/resource/${runtimeProjectName}/model/OXtype.genmodel"
+			name = "org.eclipse.osbp.xtext.oxtype.OXtype"
+			fileExtensions = "oxtype"
+
+			serializer = {
+				generateStub = false
+			}
+			
+			validator = {
+				// composedCheck = "org.eclipse.xtext.validation.NamesAreUniqueValidator"
+			}
+		}
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtype.xtext b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtype.xtext
new file mode 100644
index 0000000..4294255
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtype.xtext
@@ -0,0 +1,15 @@
+grammar org.eclipse.osbp.xtext.oxtype.OXtype with org.eclipse.xtext.xbase.annotations.XbaseWithAnnotations
+
+import "http://www.eclipse.org/xtext/xbase/Xtype"
+import "http://www.eclipse.org/xtext/common/JavaVMTypes"
+import "http://www.eclipse.org/osbp/xtext/oxtype/OXtype"
+
+@Override
+XImportDeclaration returns OXImportDeclaration: 
+	{OXImportDeclaration}
+	'import' (
+		(static?='static' extension?='extension'? importedType=[JvmDeclaredType|QualifiedNameInStaticImport] (wildcard?='*' | memberName=ValidID)) 
+		| importedType=[JvmDeclaredType|QualifiedName] 
+		| importedNamespace=QualifiedNameWithWildcard
+		| fqnImport?='ns' importedFullyQualifiedName=QualifiedName) ';'?
+;
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeRuntimeModule.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeRuntimeModule.xtend
new file mode 100644
index 0000000..6cdee2e
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeRuntimeModule.xtend
@@ -0,0 +1,11 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype
+
+
+/**
+ * Use this class to register components to be used at runtime / without the Equinox extension registry.
+ */
+class OXtypeRuntimeModule extends AbstractOXtypeRuntimeModule {
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetup.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetup.xtend
new file mode 100644
index 0000000..b2c9628
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/OXtypeStandaloneSetup.xtend
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype
+
+
+/**
+ * Initialization support for running Xtext languages without Equinox extension registry.
+ */
+class OXtypeStandaloneSetup extends OXtypeStandaloneSetupGenerated {
+
+	def static void doSetup() {
+		new OXtypeStandaloneSetup().createInjectorAndDoEMFRegistration()
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/jvmmodel/OXtypeJvmModelInferrer.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/jvmmodel/OXtypeJvmModelInferrer.xtend
new file mode 100644
index 0000000..3071fda
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/jvmmodel/OXtypeJvmModelInferrer.xtend
@@ -0,0 +1,62 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.jvmmodel
+
+import com.google.inject.Inject
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+import org.eclipse.xtext.xbase.jvmmodel.AbstractModelInferrer
+import org.eclipse.xtext.xbase.jvmmodel.IJvmDeclaredTypeAcceptor
+import org.eclipse.xtext.xbase.jvmmodel.JvmTypesBuilder
+
+/**
+ * <p>Infers a JVM model from the source model.</p> 
+ *
+ * <p>The JVM model should contain all elements that would appear in the Java code 
+ * which is generated from the source model. Other models link against the JVM model rather than the source model.</p>     
+ */
+class OXtypeJvmModelInferrer extends AbstractModelInferrer {
+
+	/**
+	 * convenience API to build and initialize JVM types and their members.
+	 */
+	@Inject extension JvmTypesBuilder
+
+	/**
+	 * The dispatch method {@code infer} is called for each instance of the
+	 * given element's type that is contained in a resource.
+	 * 
+	 * @param element
+	 *            the model to create one or more
+	 *            {@link org.eclipse.xtext.common.types.JvmDeclaredType declared
+	 *            types} from.
+	 * @param acceptor
+	 *            each created
+	 *            {@link org.eclipse.xtext.common.types.JvmDeclaredType type}
+	 *            without a container should be passed to the acceptor in order
+	 *            get attached to the current resource. The acceptor's
+	 *            {@link IJvmDeclaredTypeAcceptor#accept(org.eclipse.xtext.common.types.JvmDeclaredType)
+	 *            accept(..)} method takes the constructed empty type for the
+	 *            pre-indexing phase. This one is further initialized in the
+	 *            indexing phase using the lambda you pass as the last argument.
+	 * @param isPreIndexingPhase
+	 *            whether the method is called in a pre-indexing phase, i.e.
+	 *            when the global index is not yet fully updated. You must not
+	 *            rely on linking using the index if isPreIndexingPhase is
+	 *            <code>true</code>.
+	 */
+	def dispatch void infer(OXImportDeclaration element, IJvmDeclaredTypeAcceptor acceptor, boolean isPreIndexingPhase) {
+		// Here you explain how your model is mapped to Java elements, by writing the actual translation code.
+		
+		// An implementation for the initial hello world example could look like this:
+// 		acceptor.accept(element.toClass("my.company.greeting.MyGreetings")) [
+// 			for (greeting : element.greetings) {
+// 				members += greeting.toMethod("hello" + greeting.name, typeRef(String)) [
+// 					body = '''
+//						return "Hello «greeting.name»";
+//					'''
+//				]
+//			}
+//		]
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinker.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinker.java
new file mode 100644
index 0000000..aaea2e8
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinker.java
@@ -0,0 +1,92 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.xtext.oxtype.linking;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.util.InternalEList;
+import org.eclipse.xtext.common.types.JvmParameterizedTypeReference;
+import org.eclipse.xtext.common.types.JvmType;
+import org.eclipse.xtext.common.types.TypesFactory;
+import org.eclipse.xtext.common.types.TypesPackage;
+import org.eclipse.xtext.nodemodel.INode;
+import org.eclipse.xtext.xbase.linking.XbaseLazyLinker;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.google.inject.Inject;
+
+@SuppressWarnings("restriction")
+public class LazyJvmTypeLinker extends XbaseLazyLinker {
+
+	private static final Logger LOGGER = LoggerFactory.getLogger(LazyJvmTypeLinker.class);
+
+	@Inject
+	private LazyJvmTypeLinkingHelper jvmLinkingHelper;
+
+	@Override
+	protected void clearReference(EObject obj, EReference ref) {
+		if (jvmLinkingHelper.isJvmLink((EReference) obj.eContainingFeature())) {
+			// do not clear this reference
+			return;
+		}
+
+		super.clearReference(obj, ref);
+	}
+
+	@SuppressWarnings("unchecked")
+	protected void createAndSetProxy(EObject obj, INode node, EReference eRef) {
+		if (jvmLinkingHelper.isJvmLink(eRef)) {
+			return;
+		}
+
+		EObject proxy = createProxy(obj, node, eRef);
+		if (eRef.isMany()) {
+			((InternalEList<EObject>) obj.eGet(eRef, false)).addUnique(proxy);
+		} else {
+			obj.eSet(eRef, proxy);
+		}
+
+		if (jvmLinkingHelper.needsJvmLinking(eRef)) {
+			for (EReference jvmLinkReference : jvmLinkingHelper.getJvmLinkingReferences(eRef)) {
+				final JvmParameterizedTypeReference typeRef = TypesFactory.eINSTANCE
+						.createJvmParameterizedTypeReference();
+				if (eRef.isMany()) {
+					((InternalEList<EObject>) obj.eGet(jvmLinkReference, false)).addUnique(typeRef);
+				} else {
+					obj.eSet(jvmLinkReference, typeRef);
+				}
+
+				final JvmType jvmProxy = (JvmType) createProxy(typeRef, node,
+						TypesPackage.Literals.JVM_PARAMETERIZED_TYPE_REFERENCE__TYPE);
+				typeRef.setType(jvmProxy);
+
+				LazyJvmTypeLinkingHelper.IJvmTypeRefFinisher finisher = jvmLinkingHelper.getFinisher(jvmLinkReference);
+				if (finisher != null) {
+					finisher.finish(jvmLinkReference, typeRef);
+				}
+			}
+		}
+	}
+
+	/**
+	 * Unique name of representation.
+	 * 
+	 * @param referenceType
+	 * @param crossReferenceString
+	 * @return
+	 */
+	private String createProxyAccess(EClass referenceType, String crossReferenceString) {
+		return String.format("%s.%s.%s", referenceType.getEPackage().getNsURI(), referenceType.getName(),
+				crossReferenceString);
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinkingHelper.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinkingHelper.java
new file mode 100644
index 0000000..c3fc945
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/linking/LazyJvmTypeLinkingHelper.java
@@ -0,0 +1,204 @@
+/**
+ * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf, Austria), Loetz GmbH&Co.KG (69115 Heidelberg, Germany)
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *         Florian Pirchner - Initial implementation
+ */
+package org.eclipse.osbp.xtext.oxtype.linking;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EReference;
+import org.eclipse.emf.ecore.EStructuralFeature;
+import org.eclipse.xtext.common.types.JvmTypeReference;
+
+// TODO: Auto-generated Javadoc
+/**
+ * A helper class to register jvmLinkingReferences.
+ */
+public class LazyJvmTypeLinkingHelper {
+
+	/** The link mappings. */
+	private Map<EReference, Set<EReference>> linkMappings = new HashMap<EReference, Set<EReference>>();
+	
+	/** The jvm link to enhancers. */
+	private Map<EReference, IJvmLinkCrossRefStringEnhancer> jvmLinkToEnhancers = new HashMap<EReference, IJvmLinkCrossRefStringEnhancer>();
+	
+	/** The jvm link to finisher. */
+	private Map<EReference, IJvmTypeRefFinisher> jvmLinkToFinisher = new HashMap<EReference, IJvmTypeRefFinisher>();
+	
+	/** The jvm links. */
+	private Set<EReference> jvmLinks = new HashSet<EReference>();
+
+	/**
+	 * Instantiates a new lazy jvm type linking helper.
+	 */
+	public LazyJvmTypeLinkingHelper() {
+	}
+
+	/**
+	 * Registers a jvmTypeReference for a given semanticReference.
+	 *
+	 * @param semanticReference
+	 *            the semantic reference
+	 * @param jvmTypeReference
+	 *            the jvm type reference
+	 * @return the e reference
+	 */
+	public EReference register(EReference semanticReference,
+			EReference jvmTypeReference) {
+		return register(semanticReference, jvmTypeReference, null, null);
+	}
+
+	/**
+	 * Registers a jvmTypeReference for a given semanticReference.
+	 *
+	 * @param semanticReference
+	 *            the semantic reference
+	 * @param jvmTypeReference
+	 *            the jvm type reference
+	 * @param enhancer
+	 *            the enhancer
+	 * @param finisher
+	 *            the finisher
+	 * @return the e reference
+	 */
+	public EReference register(EReference semanticReference,
+			EReference jvmTypeReference,
+			IJvmLinkCrossRefStringEnhancer enhancer,
+			IJvmTypeRefFinisher finisher) {
+
+		Set<EReference> links = linkMappings.get(semanticReference);
+		if (links == null) {
+			links = new HashSet<EReference>();
+			linkMappings.put(semanticReference, links);
+		}
+		links.add(jvmTypeReference);
+		jvmLinks.add(jvmTypeReference);
+
+		if (enhancer != null) {
+			jvmLinkToEnhancers.put(jvmTypeReference, enhancer);
+		}
+
+		if (finisher != null) {
+			jvmLinkToFinisher.put(jvmTypeReference, finisher);
+		}
+
+		return jvmTypeReference;
+	}
+
+	/**
+	 * Returns true, if the semanticReference needs jvmLinking.
+	 *
+	 * @param semanticReference
+	 *            the semantic reference
+	 * @return true, if successful
+	 */
+	public boolean needsJvmLinking(EReference semanticReference) {
+		return linkMappings.containsKey(semanticReference);
+	}
+
+	/**
+	 * Returns true, if the given reference is a jvmLink.
+	 *
+	 * @param feature
+	 *            the feature
+	 * @return true, if is jvm link
+	 */
+	public boolean isJvmLink(EStructuralFeature feature) {
+		if (feature instanceof EReference) {
+			return jvmLinks.contains(feature);
+		} else {
+			return false;
+		}
+	}
+
+	/**
+	 * Returns the enhancer for the given feature.
+	 *
+	 * @param feature
+	 *            the feature
+	 * @return the enhancer
+	 */
+	public IJvmLinkCrossRefStringEnhancer getEnhancer(EStructuralFeature feature) {
+		return jvmLinkToEnhancers.get(feature);
+	}
+
+	/**
+	 * Returns the finisher for the given feature.
+	 *
+	 * @param feature
+	 *            the feature
+	 * @return the finisher
+	 */
+	public IJvmTypeRefFinisher getFinisher(EStructuralFeature feature) {
+		return jvmLinkToFinisher.get(feature);
+	}
+
+	/**
+	 * Returns the jvmLinkingReference for the given semanticReference.
+	 *
+	 * @param semanticReference
+	 *            the semantic reference
+	 * @return the jvm linking references
+	 */
+	public Set<EReference> getJvmLinkingReferences(EReference semanticReference) {
+		return linkMappings.get(semanticReference);
+	}
+
+	/**
+	 * The JvmLinks are a helper construct to provide proper proxies. But in
+	 * some cases the cross reference String that is used for scoping needs to
+	 * be enhanced. For instance if a DTO mapper is queried. The naming
+	 * convention defines, that a mapper is called "{DTO-FQN}Mapper". So the
+	 * jvmLink-proxy from LDto#mapperJvmType needs to become resolved with the
+	 * name of the mapper.
+	 */
+	public interface IJvmLinkCrossRefStringEnhancer {
+
+		/**
+		 * Returns the crossRefString to be used.
+		 * <p>
+		 * Example: given "ItemDTO" and returned "ItemDTOMapper".
+		 *
+		 * @param context
+		 *            the context
+		 * @param feature
+		 *            the feature
+		 * @param crossRefString
+		 *            the cross ref string
+		 * @return the string
+		 */
+		String enhance(EObject context, EStructuralFeature feature,
+				String crossRefString);
+
+	}
+
+	/**
+	 * The JvmHelperProxies will be validated by Xbase. So it is necessary to
+	 * add type arguments to raw types. This finisher gives access to the
+	 * created {@link JvmTypeReference}.
+	 */
+	public interface IJvmTypeRefFinisher {
+
+		/**
+		 * Allows to manipulate the created type reference.
+		 *
+		 * @param jvmLinkFeature
+		 *            the jvm link feature
+		 * @param typeRef
+		 *            the type ref
+		 */
+		void finish(EStructuralFeature jvmLinkFeature, JvmTypeReference typeRef);
+
+	}
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXImportDeclaration.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXImportDeclaration.java
new file mode 100644
index 0000000..86a5dba
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXImportDeclaration.java
@@ -0,0 +1,89 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype;
+
+import org.eclipse.xtext.xtype.XImportDeclaration;
+
+/**
+ * <!-- begin-user-doc --> A representation of the model object '<em><b>OX
+ * Import Declaration</b></em>'. <!-- end-user-doc -->
+ *
+ * <p>
+ * The following features are supported:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport
+ * <em>Fqn Import</em>}</li>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName
+ * <em>Imported Fully Qualified Name</em>}</li>
+ * </ul>
+ *
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#getOXImportDeclaration()
+ * @model
+ * @generated
+ */
+public interface OXImportDeclaration extends XImportDeclaration {
+	/**
+	 * Returns the value of the '<em><b>Fqn Import</b></em>' attribute. <!--
+	 * begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Fqn Import</em>' attribute isn't clear, there
+	 * really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Fqn Import</em>' attribute.
+	 * @see #setFqnImport(boolean)
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#getOXImportDeclaration_FqnImport()
+	 * @model
+	 * @generated
+	 */
+	boolean isFqnImport();
+
+	/**
+	 * Sets the value of the
+	 * '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport
+	 * <em>Fqn Import</em>}' attribute. <!-- begin-user-doc --> <!--
+	 * end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Fqn Import</em>' attribute.
+	 * @see #isFqnImport()
+	 * @generated
+	 */
+	void setFqnImport(boolean value);
+
+	/**
+	 * Returns the value of the '<em><b>Imported Fully Qualified Name</b></em>'
+	 * attribute. <!-- begin-user-doc -->
+	 * <p>
+	 * If the meaning of the '<em>Imported Fully Qualified Name</em>' attribute
+	 * isn't clear, there really should be more of a description here...
+	 * </p>
+	 * <!-- end-user-doc -->
+	 * 
+	 * @return the value of the '<em>Imported Fully Qualified Name</em>'
+	 *         attribute.
+	 * @see #setImportedFullyQualifiedName(String)
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#getOXImportDeclaration_ImportedFullyQualifiedName()
+	 * @model
+	 * @generated
+	 */
+	String getImportedFullyQualifiedName();
+
+	/**
+	 * Sets the value of the
+	 * '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName
+	 * <em>Imported Fully Qualified Name</em>}' attribute. <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * 
+	 * @param value
+	 *            the new value of the '<em>Imported Fully Qualified Name</em>'
+	 *            attribute.
+	 * @see #getImportedFullyQualifiedName()
+	 * @generated
+	 */
+	void setImportedFullyQualifiedName(String value);
+
+} // OXImportDeclaration
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypeFactory.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypeFactory.java
new file mode 100644
index 0000000..673bf99
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypeFactory.java
@@ -0,0 +1,43 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype;
+
+import org.eclipse.emf.ecore.EFactory;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Factory</b> for the model.
+ * It provides a create method for each non-abstract class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage
+ * @generated
+ */
+public interface OXtypeFactory extends EFactory {
+	/**
+	 * The singleton instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	OXtypeFactory eINSTANCE = org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypeFactoryImpl.init();
+
+	/**
+	 * Returns a new object of class '<em>OX Import Declaration</em>'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return a new object of class '<em>OX Import Declaration</em>'.
+	 * @generated
+	 */
+	OXImportDeclaration createOXImportDeclaration();
+
+	/**
+	 * Returns the package supported by this factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the package supported by this factory.
+	 * @generated
+	 */
+	OXtypePackage getOXtypePackage();
+
+} //OXtypeFactory
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypePackage.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypePackage.java
new file mode 100644
index 0000000..399ae19
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/OXtypePackage.java
@@ -0,0 +1,234 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.xtext.xtype.XtypePackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Package</b> for the model.
+ * It contains accessors for the meta objects to represent
+ * <ul>
+ *   <li>each class,</li>
+ *   <li>each feature of each class,</li>
+ *   <li>each enum,</li>
+ *   <li>and each data type</li>
+ * </ul>
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypeFactory
+ * @model kind="package"
+ * @generated
+ */
+public interface OXtypePackage extends EPackage {
+	/**
+	 * The package name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNAME = "oxtype";
+
+	/**
+	 * The package namespace URI.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_URI = "http://www.eclipse.org/osbp/xtext/oxtype/OXtype";
+
+	/**
+	 * The package namespace name.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	String eNS_PREFIX = "oxtype";
+
+	/**
+	 * The singleton instance of the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	OXtypePackage eINSTANCE = org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypePackageImpl.init();
+
+	/**
+	 * The meta object id for the '{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl <em>OX Import Declaration</em>}' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypePackageImpl#getOXImportDeclaration()
+	 * @generated
+	 */
+	int OX_IMPORT_DECLARATION = 0;
+
+	/**
+	 * The feature id for the '<em><b>Wildcard</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__WILDCARD = XtypePackage.XIMPORT_DECLARATION__WILDCARD;
+
+	/**
+	 * The feature id for the '<em><b>Extension</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__EXTENSION = XtypePackage.XIMPORT_DECLARATION__EXTENSION;
+
+	/**
+	 * The feature id for the '<em><b>Static</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__STATIC = XtypePackage.XIMPORT_DECLARATION__STATIC;
+
+	/**
+	 * The feature id for the '<em><b>Imported Type</b></em>' reference.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__IMPORTED_TYPE = XtypePackage.XIMPORT_DECLARATION__IMPORTED_TYPE;
+
+	/**
+	 * The feature id for the '<em><b>Member Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__MEMBER_NAME = XtypePackage.XIMPORT_DECLARATION__MEMBER_NAME;
+
+	/**
+	 * The feature id for the '<em><b>Imported Namespace</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__IMPORTED_NAMESPACE = XtypePackage.XIMPORT_DECLARATION__IMPORTED_NAMESPACE;
+
+	/**
+	 * The feature id for the '<em><b>Fqn Import</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__FQN_IMPORT = XtypePackage.XIMPORT_DECLARATION_FEATURE_COUNT + 0;
+
+	/**
+	 * The feature id for the '<em><b>Imported Fully Qualified Name</b></em>' attribute.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME = XtypePackage.XIMPORT_DECLARATION_FEATURE_COUNT + 1;
+
+	/**
+	 * The number of structural features of the '<em>OX Import Declaration</em>' class.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 * @ordered
+	 */
+	int OX_IMPORT_DECLARATION_FEATURE_COUNT = XtypePackage.XIMPORT_DECLARATION_FEATURE_COUNT + 2;
+
+
+	/**
+	 * Returns the meta object for class '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration <em>OX Import Declaration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for class '<em>OX Import Declaration</em>'.
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+	 * @generated
+	 */
+	EClass getOXImportDeclaration();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport <em>Fqn Import</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Fqn Import</em>'.
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#isFqnImport()
+	 * @see #getOXImportDeclaration()
+	 * @generated
+	 */
+	EAttribute getOXImportDeclaration_FqnImport();
+
+	/**
+	 * Returns the meta object for the attribute '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName <em>Imported Fully Qualified Name</em>}'.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the meta object for the attribute '<em>Imported Fully Qualified Name</em>'.
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration#getImportedFullyQualifiedName()
+	 * @see #getOXImportDeclaration()
+	 * @generated
+	 */
+	EAttribute getOXImportDeclaration_ImportedFullyQualifiedName();
+
+	/**
+	 * Returns the factory that creates the instances of the model.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the factory that creates the instances of the model.
+	 * @generated
+	 */
+	OXtypeFactory getOXtypeFactory();
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * Defines literals for the meta objects that represent
+	 * <ul>
+	 *   <li>each class,</li>
+	 *   <li>each feature of each class,</li>
+	 *   <li>each enum,</li>
+	 *   <li>and each data type</li>
+	 * </ul>
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	interface Literals {
+		/**
+		 * The meta object literal for the '{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl <em>OX Import Declaration</em>}' class.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl
+		 * @see org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXtypePackageImpl#getOXImportDeclaration()
+		 * @generated
+		 */
+		EClass OX_IMPORT_DECLARATION = eINSTANCE.getOXImportDeclaration();
+
+		/**
+		 * The meta object literal for the '<em><b>Fqn Import</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute OX_IMPORT_DECLARATION__FQN_IMPORT = eINSTANCE.getOXImportDeclaration_FqnImport();
+
+		/**
+		 * The meta object literal for the '<em><b>Imported Fully Qualified Name</b></em>' attribute feature.
+		 * <!-- begin-user-doc -->
+		 * <!-- end-user-doc -->
+		 * @generated
+		 */
+		EAttribute OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME = eINSTANCE.getOXImportDeclaration_ImportedFullyQualifiedName();
+
+	}
+
+} //OXtypePackage
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXImportDeclarationImpl.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXImportDeclarationImpl.java
new file mode 100644
index 0000000..359e116
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXImportDeclarationImpl.java
@@ -0,0 +1,225 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.impl;
+
+import org.eclipse.emf.common.notify.Notification;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.impl.ENotificationImpl;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
+import org.eclipse.xtext.xtype.impl.XImportDeclarationImplCustom;
+
+/**
+ * <!-- begin-user-doc --> An implementation of the model object '<em><b>OX
+ * Import Declaration</b></em>'. <!-- end-user-doc -->
+ * <p>
+ * The following features are implemented:
+ * </p>
+ * <ul>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl#isFqnImport
+ * <em>Fqn Import</em>}</li>
+ * <li>{@link org.eclipse.osbp.xtext.oxtype.oxtype.impl.OXImportDeclarationImpl#getImportedFullyQualifiedName
+ * <em>Imported Fully Qualified Name</em>}</li>
+ * </ul>
+ *
+ * ATTENTION:<br>
+ * Needs to extend XImportDeclarationImplCustom!
+ */
+@SuppressWarnings("restriction")
+public class OXImportDeclarationImpl extends XImportDeclarationImplCustom implements OXImportDeclaration {
+	/**
+	 * The default value of the '{@link #isFqnImport() <em>Fqn Import</em>}'
+	 * attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #isFqnImport()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final boolean FQN_IMPORT_EDEFAULT = false;
+
+	/**
+	 * The cached value of the '{@link #isFqnImport() <em>Fqn Import</em>}'
+	 * attribute. <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @see #isFqnImport()
+	 * @generated
+	 * @ordered
+	 */
+	protected boolean fqnImport = FQN_IMPORT_EDEFAULT;
+
+	/**
+	 * The default value of the '{@link #getImportedFullyQualifiedName()
+	 * <em>Imported Fully Qualified Name</em>}' attribute. <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * 
+	 * @see #getImportedFullyQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected static final String IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT = null;
+
+	/**
+	 * The cached value of the '{@link #getImportedFullyQualifiedName()
+	 * <em>Imported Fully Qualified Name</em>}' attribute. <!-- begin-user-doc
+	 * --> <!-- end-user-doc -->
+	 * 
+	 * @see #getImportedFullyQualifiedName()
+	 * @generated
+	 * @ordered
+	 */
+	protected String importedFullyQualifiedName = IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT;
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	protected OXImportDeclarationImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	protected EClass eStaticClass() {
+		return OXtypePackage.Literals.OX_IMPORT_DECLARATION;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public boolean isFqnImport() {
+		return fqnImport;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setFqnImport(boolean newFqnImport) {
+		boolean oldFqnImport = fqnImport;
+		fqnImport = newFqnImport;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET, OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT,
+					oldFqnImport, fqnImport));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public String getImportedFullyQualifiedName() {
+		return importedFullyQualifiedName;
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	public void setImportedFullyQualifiedName(String newImportedFullyQualifiedName) {
+		String oldImportedFullyQualifiedName = importedFullyQualifiedName;
+		importedFullyQualifiedName = newImportedFullyQualifiedName;
+		if (eNotificationRequired())
+			eNotify(new ENotificationImpl(this, Notification.SET,
+					OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME, oldImportedFullyQualifiedName,
+					importedFullyQualifiedName));
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public Object eGet(int featureID, boolean resolve, boolean coreType) {
+		switch (featureID) {
+		case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+			return isFqnImport();
+		case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+			return getImportedFullyQualifiedName();
+		}
+		return super.eGet(featureID, resolve, coreType);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public void eSet(int featureID, Object newValue) {
+		switch (featureID) {
+		case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+			setFqnImport((Boolean) newValue);
+			return;
+		case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+			setImportedFullyQualifiedName((String) newValue);
+			return;
+		}
+		super.eSet(featureID, newValue);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public void eUnset(int featureID) {
+		switch (featureID) {
+		case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+			setFqnImport(FQN_IMPORT_EDEFAULT);
+			return;
+		case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+			setImportedFullyQualifiedName(IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT);
+			return;
+		}
+		super.eUnset(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public boolean eIsSet(int featureID) {
+		switch (featureID) {
+		case OXtypePackage.OX_IMPORT_DECLARATION__FQN_IMPORT:
+			return fqnImport != FQN_IMPORT_EDEFAULT;
+		case OXtypePackage.OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME:
+			return IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT == null ? importedFullyQualifiedName != null
+					: !IMPORTED_FULLY_QUALIFIED_NAME_EDEFAULT.equals(importedFullyQualifiedName);
+		}
+		return super.eIsSet(featureID);
+	}
+
+	/**
+	 * <!-- begin-user-doc --> <!-- end-user-doc -->
+	 * 
+	 * @generated
+	 */
+	@Override
+	public String toString() {
+		if (eIsProxy())
+			return super.toString();
+
+		StringBuffer result = new StringBuffer(super.toString());
+		result.append(" (fqnImport: ");
+		result.append(fqnImport);
+		result.append(", importedFullyQualifiedName: ");
+		result.append(importedFullyQualifiedName);
+		result.append(')');
+		return result.toString();
+	}
+
+} // OXImportDeclarationImpl
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypeFactoryImpl.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypeFactoryImpl.java
new file mode 100644
index 0000000..45d9c2d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypeFactoryImpl.java
@@ -0,0 +1,96 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.impl;
+
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EFactoryImpl;
+
+import org.eclipse.emf.ecore.plugin.EcorePlugin;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.*;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Factory</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class OXtypeFactoryImpl extends EFactoryImpl implements OXtypeFactory {
+	/**
+	 * Creates the default factory implementation.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public static OXtypeFactory init() {
+		try {
+			OXtypeFactory theOXtypeFactory = (OXtypeFactory)EPackage.Registry.INSTANCE.getEFactory(OXtypePackage.eNS_URI);
+			if (theOXtypeFactory != null) {
+				return theOXtypeFactory;
+			}
+		}
+		catch (Exception exception) {
+			EcorePlugin.INSTANCE.log(exception);
+		}
+		return new OXtypeFactoryImpl();
+	}
+
+	/**
+	 * Creates an instance of the factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public OXtypeFactoryImpl() {
+		super();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	@Override
+	public EObject create(EClass eClass) {
+		switch (eClass.getClassifierID()) {
+			case OXtypePackage.OX_IMPORT_DECLARATION: return createOXImportDeclaration();
+			default:
+				throw new IllegalArgumentException("The class '" + eClass.getName() + "' is not a valid classifier");
+		}
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public OXImportDeclaration createOXImportDeclaration() {
+		OXImportDeclarationImpl oxImportDeclaration = new OXImportDeclarationImpl();
+		return oxImportDeclaration;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public OXtypePackage getOXtypePackage() {
+		return (OXtypePackage)getEPackage();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @deprecated
+	 * @generated
+	 */
+	@Deprecated
+	public static OXtypePackage getPackage() {
+		return OXtypePackage.eINSTANCE;
+	}
+
+} //OXtypeFactoryImpl
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypePackageImpl.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypePackageImpl.java
new file mode 100644
index 0000000..72af35f
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/impl/OXtypePackageImpl.java
@@ -0,0 +1,201 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.impl;
+
+import org.eclipse.emf.ecore.EAttribute;
+import org.eclipse.emf.ecore.EClass;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.impl.EPackageImpl;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypeFactory;
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage;
+
+import org.eclipse.xtext.common.types.TypesPackage;
+
+import org.eclipse.xtext.xtype.XtypePackage;
+
+/**
+ * <!-- begin-user-doc -->
+ * An implementation of the model <b>Package</b>.
+ * <!-- end-user-doc -->
+ * @generated
+ */
+public class OXtypePackageImpl extends EPackageImpl implements OXtypePackage {
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private EClass oxImportDeclarationEClass = null;
+
+	/**
+	 * Creates an instance of the model <b>Package</b>, registered with
+	 * {@link org.eclipse.emf.ecore.EPackage.Registry EPackage.Registry} by the package
+	 * package URI value.
+	 * <p>Note: the correct way to create the package is via the static
+	 * factory method {@link #init init()}, which also performs
+	 * initialization of the package, or returns the registered package,
+	 * if one already exists.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see org.eclipse.emf.ecore.EPackage.Registry
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage#eNS_URI
+	 * @see #init()
+	 * @generated
+	 */
+	private OXtypePackageImpl() {
+		super(eNS_URI, OXtypeFactory.eINSTANCE);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private static boolean isInited = false;
+
+	/**
+	 * Creates, registers, and initializes the <b>Package</b> for this model, and for any others upon which it depends.
+	 * 
+	 * <p>This method is used to initialize {@link OXtypePackage#eINSTANCE} when that field is accessed.
+	 * Clients should not invoke it directly. Instead, they should simply access that field to obtain the package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @see #eNS_URI
+	 * @see #createPackageContents()
+	 * @see #initializePackageContents()
+	 * @generated
+	 */
+	public static OXtypePackage init() {
+		if (isInited) return (OXtypePackage)EPackage.Registry.INSTANCE.getEPackage(OXtypePackage.eNS_URI);
+
+		// Obtain or create and register package
+		OXtypePackageImpl theOXtypePackage = (OXtypePackageImpl)(EPackage.Registry.INSTANCE.get(eNS_URI) instanceof OXtypePackageImpl ? EPackage.Registry.INSTANCE.get(eNS_URI) : new OXtypePackageImpl());
+
+		isInited = true;
+
+		// Initialize simple dependencies
+		XtypePackage.eINSTANCE.eClass();
+		TypesPackage.eINSTANCE.eClass();
+
+		// Create package meta-data objects
+		theOXtypePackage.createPackageContents();
+
+		// Initialize created meta-data
+		theOXtypePackage.initializePackageContents();
+
+		// Mark meta-data to indicate it can't be changed
+		theOXtypePackage.freeze();
+
+  
+		// Update the registry and return the package
+		EPackage.Registry.INSTANCE.put(OXtypePackage.eNS_URI, theOXtypePackage);
+		return theOXtypePackage;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EClass getOXImportDeclaration() {
+		return oxImportDeclarationEClass;
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getOXImportDeclaration_FqnImport() {
+		return (EAttribute)oxImportDeclarationEClass.getEStructuralFeatures().get(0);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public EAttribute getOXImportDeclaration_ImportedFullyQualifiedName() {
+		return (EAttribute)oxImportDeclarationEClass.getEStructuralFeatures().get(1);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public OXtypeFactory getOXtypeFactory() {
+		return (OXtypeFactory)getEFactoryInstance();
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isCreated = false;
+
+	/**
+	 * Creates the meta-model objects for the package.  This method is
+	 * guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void createPackageContents() {
+		if (isCreated) return;
+		isCreated = true;
+
+		// Create classes and their features
+		oxImportDeclarationEClass = createEClass(OX_IMPORT_DECLARATION);
+		createEAttribute(oxImportDeclarationEClass, OX_IMPORT_DECLARATION__FQN_IMPORT);
+		createEAttribute(oxImportDeclarationEClass, OX_IMPORT_DECLARATION__IMPORTED_FULLY_QUALIFIED_NAME);
+	}
+
+	/**
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	private boolean isInitialized = false;
+
+	/**
+	 * Complete the initialization of the package and its meta-model.  This
+	 * method is guarded to have no affect on any invocation but its first.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public void initializePackageContents() {
+		if (isInitialized) return;
+		isInitialized = true;
+
+		// Initialize package
+		setName(eNAME);
+		setNsPrefix(eNS_PREFIX);
+		setNsURI(eNS_URI);
+
+		// Obtain other dependent packages
+		XtypePackage theXtypePackage = (XtypePackage)EPackage.Registry.INSTANCE.getEPackage(XtypePackage.eNS_URI);
+
+		// Create type parameters
+
+		// Set bounds for type parameters
+
+		// Add supertypes to classes
+		oxImportDeclarationEClass.getESuperTypes().add(theXtypePackage.getXImportDeclaration());
+
+		// Initialize classes and features; add operations and parameters
+		initEClass(oxImportDeclarationEClass, OXImportDeclaration.class, "OXImportDeclaration", !IS_ABSTRACT, !IS_INTERFACE, IS_GENERATED_INSTANCE_CLASS);
+		initEAttribute(getOXImportDeclaration_FqnImport(), ecorePackage.getEBoolean(), "fqnImport", null, 0, 1, OXImportDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+		initEAttribute(getOXImportDeclaration_ImportedFullyQualifiedName(), ecorePackage.getEString(), "importedFullyQualifiedName", null, 0, 1, OXImportDeclaration.class, !IS_TRANSIENT, !IS_VOLATILE, IS_CHANGEABLE, !IS_UNSETTABLE, !IS_ID, IS_UNIQUE, !IS_DERIVED, IS_ORDERED);
+
+		// Create resource
+		createResource(eNS_URI);
+	}
+
+} //OXtypePackageImpl
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeAdapterFactory.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeAdapterFactory.java
new file mode 100644
index 0000000..0db98dc
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeAdapterFactory.java
@@ -0,0 +1,141 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.util;
+
+import org.eclipse.emf.common.notify.Adapter;
+import org.eclipse.emf.common.notify.Notifier;
+
+import org.eclipse.emf.common.notify.impl.AdapterFactoryImpl;
+
+import org.eclipse.emf.ecore.EObject;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.*;
+
+import org.eclipse.xtext.xtype.XImportDeclaration;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Adapter Factory</b> for the model.
+ * It provides an adapter <code>createXXX</code> method for each class of the model.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage
+ * @generated
+ */
+public class OXtypeAdapterFactory extends AdapterFactoryImpl {
+	/**
+	 * The cached model package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static OXtypePackage modelPackage;
+
+	/**
+	 * Creates an instance of the adapter factory.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public OXtypeAdapterFactory() {
+		if (modelPackage == null) {
+			modelPackage = OXtypePackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Returns whether this factory is applicable for the type of the object.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns <code>true</code> if the object is either the model's package or is an instance object of the model.
+	 * <!-- end-user-doc -->
+	 * @return whether this factory is applicable for the type of the object.
+	 * @generated
+	 */
+	@Override
+	public boolean isFactoryForType(Object object) {
+		if (object == modelPackage) {
+			return true;
+		}
+		if (object instanceof EObject) {
+			return ((EObject)object).eClass().getEPackage() == modelPackage;
+		}
+		return false;
+	}
+
+	/**
+	 * The switch that delegates to the <code>createXXX</code> methods.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected OXtypeSwitch<Adapter> modelSwitch =
+		new OXtypeSwitch<Adapter>() {
+			@Override
+			public Adapter caseOXImportDeclaration(OXImportDeclaration object) {
+				return createOXImportDeclarationAdapter();
+			}
+			@Override
+			public Adapter caseXImportDeclaration(XImportDeclaration object) {
+				return createXImportDeclarationAdapter();
+			}
+			@Override
+			public Adapter defaultCase(EObject object) {
+				return createEObjectAdapter();
+			}
+		};
+
+	/**
+	 * Creates an adapter for the <code>target</code>.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param target the object to adapt.
+	 * @return the adapter for the <code>target</code>.
+	 * @generated
+	 */
+	@Override
+	public Adapter createAdapter(Notifier target) {
+		return modelSwitch.doSwitch((EObject)target);
+	}
+
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration <em>OX Import Declaration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+	 * @generated
+	 */
+	public Adapter createOXImportDeclarationAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for an object of class '{@link org.eclipse.xtext.xtype.XImportDeclaration <em>XImport Declaration</em>}'.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null so that we can easily ignore cases;
+	 * it's useful to ignore a case when inheritance will catch all the cases anyway.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @see org.eclipse.xtext.xtype.XImportDeclaration
+	 * @generated
+	 */
+	public Adapter createXImportDeclarationAdapter() {
+		return null;
+	}
+
+	/**
+	 * Creates a new adapter for the default case.
+	 * <!-- begin-user-doc -->
+	 * This default implementation returns null.
+	 * <!-- end-user-doc -->
+	 * @return the new adapter.
+	 * @generated
+	 */
+	public Adapter createEObjectAdapter() {
+		return null;
+	}
+
+} //OXtypeAdapterFactory
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeSwitch.java b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeSwitch.java
new file mode 100644
index 0000000..41ef37d
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/oxtype/util/OXtypeSwitch.java
@@ -0,0 +1,129 @@
+/**
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.oxtype.util;
+
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.emf.ecore.EPackage;
+
+import org.eclipse.emf.ecore.util.Switch;
+
+import org.eclipse.osbp.xtext.oxtype.oxtype.*;
+
+import org.eclipse.xtext.xtype.XImportDeclaration;
+
+/**
+ * <!-- begin-user-doc -->
+ * The <b>Switch</b> for the model's inheritance hierarchy.
+ * It supports the call {@link #doSwitch(EObject) doSwitch(object)}
+ * to invoke the <code>caseXXX</code> method for each class of the model,
+ * starting with the actual class of the object
+ * and proceeding up the inheritance hierarchy
+ * until a non-null result is returned,
+ * which is the result of the switch.
+ * <!-- end-user-doc -->
+ * @see org.eclipse.osbp.xtext.oxtype.oxtype.OXtypePackage
+ * @generated
+ */
+public class OXtypeSwitch<T> extends Switch<T> {
+	/**
+	 * The cached model package
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	protected static OXtypePackage modelPackage;
+
+	/**
+	 * Creates an instance of the switch.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @generated
+	 */
+	public OXtypeSwitch() {
+		if (modelPackage == null) {
+			modelPackage = OXtypePackage.eINSTANCE;
+		}
+	}
+
+	/**
+	 * Checks whether this is a switch for the given package.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @param ePackage the package in question.
+	 * @return whether this is a switch for the given package.
+	 * @generated
+	 */
+	@Override
+	protected boolean isSwitchFor(EPackage ePackage) {
+		return ePackage == modelPackage;
+	}
+
+	/**
+	 * Calls <code>caseXXX</code> for each class of the model until one returns a non null result; it yields that result.
+	 * <!-- begin-user-doc -->
+	 * <!-- end-user-doc -->
+	 * @return the first non-null result returned by a <code>caseXXX</code> call.
+	 * @generated
+	 */
+	@Override
+	protected T doSwitch(int classifierID, EObject theEObject) {
+		switch (classifierID) {
+			case OXtypePackage.OX_IMPORT_DECLARATION: {
+				OXImportDeclaration oxImportDeclaration = (OXImportDeclaration)theEObject;
+				T result = caseOXImportDeclaration(oxImportDeclaration);
+				if (result == null) result = caseXImportDeclaration(oxImportDeclaration);
+				if (result == null) result = defaultCase(theEObject);
+				return result;
+			}
+			default: return defaultCase(theEObject);
+		}
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>OX Import Declaration</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>OX Import Declaration</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseOXImportDeclaration(OXImportDeclaration object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>XImport Declaration</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>XImport Declaration</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject) doSwitch(EObject)
+	 * @generated
+	 */
+	public T caseXImportDeclaration(XImportDeclaration object) {
+		return null;
+	}
+
+	/**
+	 * Returns the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * <!-- begin-user-doc -->
+	 * This implementation returns null;
+	 * returning a non-null result will terminate the switch, but this is the last case anyway.
+	 * <!-- end-user-doc -->
+	 * @param object the target of the switch.
+	 * @return the result of interpreting the object as an instance of '<em>EObject</em>'.
+	 * @see #doSwitch(org.eclipse.emf.ecore.EObject)
+	 * @generated
+	 */
+	@Override
+	public T defaultCase(EObject object) {
+		return null;
+	}
+
+} //OXtypeSwitch
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXImportSectionNamespaceScopeProvider.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXImportSectionNamespaceScopeProvider.xtend
new file mode 100644
index 0000000..591303a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXImportSectionNamespaceScopeProvider.xtend
@@ -0,0 +1,32 @@
+package org.eclipse.osbp.xtext.oxtype.scoping
+
+import com.google.common.collect.Lists
+import java.util.List
+import org.eclipse.osbp.xtext.oxtype.oxtype.OXImportDeclaration
+import org.eclipse.xtext.scoping.impl.ImportNormalizer
+import org.eclipse.xtext.xtype.XImportDeclaration
+import org.eclipse.xtext.xtype.XImportSection
+import org.eclipse.xtext.xbase.scoping.XImportSectionNamespaceScopeProvider
+
+@SuppressWarnings("restriction")
+class OXImportSectionNamespaceScopeProvider extends XImportSectionNamespaceScopeProvider{
+
+	override List<ImportNormalizer> getImportedNamespaceResolvers(XImportSection importSection, boolean ignoreCase) {
+		val List<XImportDeclaration> importDeclarations = importSection.getImportDeclarations();
+		val List<ImportNormalizer> result = Lists.newArrayListWithExpectedSize(importDeclarations.size());
+		for (XImportDeclaration imp : importDeclarations) {
+			if (!imp.isStatic()) {
+				val OXImportDeclaration decl = imp as OXImportDeclaration;
+				var String value = decl.getImportedFullyQualifiedName();
+				if (value === null)
+					value = imp.getImportedNamespace();
+				if (value === null)
+					value = imp.getImportedTypeName();
+				val ImportNormalizer resolver = createImportedNamespaceResolver(value, ignoreCase);
+				if (resolver !== null)
+					result.add(resolver);
+			}
+		}
+		return result;
+	}
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXtypeScopeProvider.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXtypeScopeProvider.xtend
new file mode 100644
index 0000000..d1ed2f3
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/scoping/OXtypeScopeProvider.xtend
@@ -0,0 +1,15 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.scoping
+
+
+/**
+ * This class contains custom scoping description.
+ * 
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#scoping
+ * on how and when to use it.
+ */
+class OXtypeScopeProvider extends AbstractOXtypeScopeProvider {
+
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeJavaValidator.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeJavaValidator.xtend
new file mode 100644
index 0000000..c34f794
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeJavaValidator.xtend
@@ -0,0 +1,25 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.validation
+
+
+/**
+ * This class contains custom validation rules. 
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+class OXtypeJavaValidator extends AbstractOXtypeValidator {
+	
+//	public static val INVALID_NAME = 'invalidName'
+//
+//	@Check
+//	def checkGreetingStartsWithCapital(Greeting greeting) {
+//		if (!Character.isUpperCase(greeting.name.charAt(0))) {
+//			warning('Name should start with a capital', 
+//					OXtypePackage.Literals.GREETING__NAME,
+//					INVALID_NAME)
+//		}
+//	}
+	
+}
diff --git a/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeValidator.xtend b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeValidator.xtend
new file mode 100644
index 0000000..7c89104
--- /dev/null
+++ b/org.eclipse.osbp.xtext.oxtype/src/org/eclipse/osbp/xtext/oxtype/validation/OXtypeValidator.xtend
@@ -0,0 +1,25 @@
+/*
+ * generated by Xtext 2.11.0.beta2
+ */
+package org.eclipse.osbp.xtext.oxtype.validation
+
+
+/**
+ * This class contains custom validation rules. 
+ *
+ * See https://www.eclipse.org/Xtext/documentation/303_runtime_concepts.html#validation
+ */
+class OXtypeValidator extends AbstractOXtypeValidator {
+	
+//	public static val INVALID_NAME = 'invalidName'
+//
+//	@Check
+//	def checkGreetingStartsWithCapital(Greeting greeting) {
+//		if (!Character.isUpperCase(greeting.name.charAt(0))) {
+//			warning('Name should start with a capital', 
+//					OXtypePackage.Literals.GREETING__NAME,
+//					INVALID_NAME)
+//		}
+//	}
+	
+}
diff --git a/pom.xml b/pom.xml
new file mode 100644
index 0000000..eec4da2
--- /dev/null
+++ b/pom.xml
@@ -0,0 +1,112 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+#=======================================================================
+# Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany).
+# All rights reserved. This program and the accompanying materials
+# are made available under the terms of the Eclipse Public License v1.0
+# which accompanies this distribution, and is available at
+# http://www.eclipse.org/legal/epl-v10.html
+# 
+# Contributors:
+# Loetz GmbH&Co.KG - initial API and implementation 
+#=======================================================================
+-->
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>org.eclipse.osbp.releng.maven</groupId>
+        <artifactId>org.eclipse.osbp.releng.maven.parent.tycho</artifactId>
+        <version>0.9.0-SNAPSHOT</version>
+        <relativePath/>
+    </parent>
+
+    <groupId>org.eclipse.osbp.xtext.oxtype</groupId>
+    <artifactId>org.eclipse.osbp.xtext.oxtype.aggregator</artifactId>
+    <packaging>pom</packaging>
+
+    <url>${osbp.site.repository.url}</url>
+    <scm>
+        <url>${osbp.scm.url}</url>
+        <connection>${osbp.scm.connection}</connection>
+        <developerConnection>${osbp.scm.connection.dev}</developerConnection>
+        <tag>HEAD</tag>
+    </scm>
+    <distributionManagement>
+        <site>
+            <id>gh-pages</id>
+            <name>OSBP GitHub Pages</name>
+            <url>${distribution.site.url}</url>
+        </site>
+    </distributionManagement>
+
+    <properties>
+        
+		<osbp.gitrepo.name>${project.groupId}</osbp.gitrepo.name>
+		<xtextVersion>2.7.3</xtextVersion>
+    </properties>
+
+    <modules>
+        <module>org.eclipse.osbp.xtext.oxtype</module>
+        <module>org.eclipse.osbp.xtext.oxtype.ide</module>
+        <module>org.eclipse.osbp.xtext.oxtype.tests</module>
+        <module>org.eclipse.osbp.xtext.oxtype.ui</module>
+        <module>org.eclipse.osbp.xtext.oxtype.ui.tests</module>
+        <module>org.eclipse.osbp.xtext.oxtype.feature</module>
+    </modules>
+
+    <build>
+        <pluginManagement>
+            <plugins>
+                <plugin>
+                    <groupId>org.apache.maven.plugins</groupId>
+                    <artifactId>maven-javadoc-plugin</artifactId>
+                    <configuration>
+                        <skip>true</skip>
+                    </configuration>
+                </plugin>
+                <plugin>
+                    <groupId>org.eclipse.tycho</groupId>
+                    <artifactId>target-platform-configuration</artifactId>
+                    <version>${tycho-version}</version>
+                    <configuration>
+                        <filters>
+                            <filter>
+                                <type>eclipse-plugin</type>
+                                <id>org.apache.aries.transaction.manager</id>
+                                <restrictTo>
+                                    <!--  use a range that does not exist, we can not mix removeall and versionRange -->
+                                    <versionRange>[0.5.0,0.5.1)</versionRange>
+                                </restrictTo>
+                            </filter>
+                        </filters>
+                        <resolver>p2</resolver>
+                        <pomDependencies>consider</pomDependencies>
+                        <environments>
+                            <environment>
+                                <os>win32</os>
+                                <ws>win32</ws>
+                                <arch>x86_64</arch>
+                            </environment>
+                            <environment>
+                                <os>linux</os>
+                                <ws>gtk</ws>
+                                <arch>x86</arch>
+                            </environment>
+                            <environment>
+                                <os>linux</os>
+                                <ws>gtk</ws>
+                                <arch>x86_64</arch>
+                            </environment>
+                            <environment>
+                                <os>macosx</os>
+                                <ws>cocoa</ws>
+                                <arch>x86_64</arch>
+                            </environment>
+                        </environments>
+                    </configuration>
+                </plugin>
+            </plugins>
+        </pluginManagement>
+    </build>
+</project>
author	Ralf Mollik	2017-08-28 15:41:57 +0000
committer	Ralf Mollik	2017-08-28 15:41:57 +0000
commit	6150c5c782fca1aabfa5910b9e584ebcad9ff3ce (patch)
tree	23f37ef7cab96069de826f5c9fd4c2238826dbd5
download	org.eclipse.osbp.xtext.oxtype-6150c5c782fca1aabfa5910b9e584ebcad9ff3ce.tar.gz org.eclipse.osbp.xtext.oxtype-6150c5c782fca1aabfa5910b9e584ebcad9ff3ce.tar.xz org.eclipse.osbp.xtext.oxtype-6150c5c782fca1aabfa5910b9e584ebcad9ff3ce.zip