parallel ip - initial checkin

Signed-off-by: Ralf Mollik <ramollik@compex-commerce.com>

1 files changed, 10014 insertions, 0 deletions

diff --git a/org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g b/org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g
new file mode 100644
index 0000000..f67e44a
--- /dev/null
+++ b/org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g
@@ -0,0 +1,10014 @@
+/**
+ *                                                                            
+ *  Copyright (c) 2011, 2016 - Loetz GmbH&Co.KG (69115 Heidelberg, Germany) 
+ *                                                                            
+ *  All rights reserved. This program and the accompanying materials           
+ *  are made available under the terms of the Eclipse Public License v1.0       
+ *  which accompanies this distribution, and is available at                  
+ *  http://www.eclipse.org/legal/epl-v10.html                                 
+ *                                                                            
+ *  Contributors:                                                      
+ * 	   Christophe Loetz (Loetz GmbH&Co.KG) - initial implementation
+ * 
+ */
+grammar InternalTableDSL;
+
+options {
+	superClass=AbstractInternalContentAssistParser;
+	backtrack=true;
+	
+}
+
+@lexer::header {
+package org.eclipse.osbp.xtext.table.ui.contentassist.antlr.internal;
+
+// Hack: Use our own Lexer superclass by means of import. 
+// Currently there is no other way to specify the superclass for the lexer.
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.Lexer;
+}
+
+@parser::header {
+package org.eclipse.osbp.xtext.table.ui.contentassist.antlr.internal; 
+
+import java.io.InputStream;
+import org.eclipse.xtext.*;
+import org.eclipse.xtext.parser.*;
+import org.eclipse.xtext.parser.impl.*;
+import org.eclipse.emf.ecore.util.EcoreUtil;
+import org.eclipse.emf.ecore.EObject;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream;
+import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
+import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
+import org.eclipse.osbp.xtext.table.services.TableDSLGrammarAccess;
+
+}
+
+@parser::members {
+ 
+ 	private TableDSLGrammarAccess grammarAccess;
+ 	
+    public void setGrammarAccess(TableDSLGrammarAccess grammarAccess) {
+    	this.grammarAccess = grammarAccess;
+    }
+    
+    @Override
+    protected Grammar getGrammar() {
+    	return grammarAccess.getGrammar();
+    }
+    
+    @Override
+    protected String getValueForTokenName(String tokenName) {
+    	return tokenName;
+    }
+
+}
+
+
+
+
+// Entry rule entryRuleTableModel
+entryRuleTableModel 
+:
+{ before(grammarAccess.getTableModelRule()); }
+	 ruleTableModel
+{ after(grammarAccess.getTableModelRule()); } 
+	 EOF 
+;
+
+// Rule TableModel
+ruleTableModel
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableModelAccess().getPackagesAssignment()); }
+(rule__TableModel__PackagesAssignment)*
+{ after(grammarAccess.getTableModelAccess().getPackagesAssignment()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTablePackage
+entryRuleTablePackage 
+:
+{ before(grammarAccess.getTablePackageRule()); }
+	 ruleTablePackage
+{ after(grammarAccess.getTablePackageRule()); } 
+	 EOF 
+;
+
+// Rule TablePackage
+ruleTablePackage
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTablePackageAccess().getGroup()); }
+(rule__TablePackage__Group__0)
+{ after(grammarAccess.getTablePackageAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTable
+entryRuleTable 
+:
+{ before(grammarAccess.getTableRule()); }
+	 ruleTable
+{ after(grammarAccess.getTableRule()); } 
+	 EOF 
+;
+
+// Rule Table
+ruleTable
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableAccess().getGroup()); }
+(rule__Table__Group__0)
+{ after(grammarAccess.getTableAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableOption
+entryRuleTableOption 
+:
+{ before(grammarAccess.getTableOptionRule()); }
+	 ruleTableOption
+{ after(grammarAccess.getTableOptionRule()); } 
+	 EOF 
+;
+
+// Rule TableOption
+ruleTableOption
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableOptionAccess().getAlternatives()); }
+(rule__TableOption__Alternatives)
+{ after(grammarAccess.getTableOptionAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableSelection
+entryRuleTableSelection 
+:
+{ before(grammarAccess.getTableSelectionRule()); }
+	 ruleTableSelection
+{ after(grammarAccess.getTableSelectionRule()); } 
+	 EOF 
+;
+
+// Rule TableSelection
+ruleTableSelection
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableSelectionAccess().getGroup()); }
+(rule__TableSelection__Group__0)
+{ after(grammarAccess.getTableSelectionAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTable
+entryRuleTableTable 
+:
+{ before(grammarAccess.getTableTableRule()); }
+	 ruleTableTable
+{ after(grammarAccess.getTableTableRule()); } 
+	 EOF 
+;
+
+// Rule TableTable
+ruleTableTable
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableTableAccess().getGroup()); }
+(rule__TableTable__Group__0)
+{ after(grammarAccess.getTableTableAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTablePreorder
+entryRuleTablePreorder 
+:
+{ before(grammarAccess.getTablePreorderRule()); }
+	 ruleTablePreorder
+{ after(grammarAccess.getTablePreorderRule()); } 
+	 EOF 
+;
+
+// Rule TablePreorder
+ruleTablePreorder
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTablePreorderAccess().getGroup()); }
+(rule__TablePreorder__Group__0)
+{ after(grammarAccess.getTablePreorderAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableValue
+entryRuleTableValue 
+:
+{ before(grammarAccess.getTableValueRule()); }
+	 ruleTableValue
+{ after(grammarAccess.getTableValueRule()); } 
+	 EOF 
+;
+
+// Rule TableValue
+ruleTableValue
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableValueAccess().getGroup()); }
+(rule__TableValue__Group__0)
+{ after(grammarAccess.getTableValueAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableFormatter
+entryRuleTableFormatter 
+:
+{ before(grammarAccess.getTableFormatterRule()); }
+	 ruleTableFormatter
+{ after(grammarAccess.getTableFormatterRule()); } 
+	 EOF 
+;
+
+// Rule TableFormatter
+ruleTableFormatter
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableFormatterAccess().getGroup()); }
+(rule__TableFormatter__Group__0)
+{ after(grammarAccess.getTableFormatterAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableImage
+entryRuleTableImage 
+:
+{ before(grammarAccess.getTableImageRule()); }
+	 ruleTableImage
+{ after(grammarAccess.getTableImageRule()); } 
+	 EOF 
+;
+
+// Rule TableImage
+ruleTableImage
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableImageAccess().getGroup()); }
+(rule__TableImage__Group__0)
+{ after(grammarAccess.getTableImageAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTooltipPattern
+entryRuleTableTooltipPattern 
+:
+{ before(grammarAccess.getTableTooltipPatternRule()); }
+	 ruleTableTooltipPattern
+{ after(grammarAccess.getTableTooltipPatternRule()); } 
+	 EOF 
+;
+
+// Rule TableTooltipPattern
+ruleTableTooltipPattern
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getGroup()); }
+(rule__TableTooltipPattern__Group__0)
+{ after(grammarAccess.getTableTooltipPatternAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableValueElement
+entryRuleTableValueElement 
+:
+{ before(grammarAccess.getTableValueElementRule()); }
+	 ruleTableValueElement
+{ after(grammarAccess.getTableValueElementRule()); } 
+	 EOF 
+;
+
+// Rule TableValueElement
+ruleTableValueElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableValueElementAccess().getAlternatives()); }
+(rule__TableValueElement__Alternatives)
+{ after(grammarAccess.getTableValueElementAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTask
+entryRuleTableTask 
+:
+{ before(grammarAccess.getTableTaskRule()); }
+	 ruleTableTask
+{ after(grammarAccess.getTableTaskRule()); } 
+	 EOF 
+;
+
+// Rule TableTask
+ruleTableTask
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableTaskAccess().getGroup()); }
+(rule__TableTask__Group__0)
+{ after(grammarAccess.getTableTaskAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableAllColumns
+entryRuleTableAllColumns 
+:
+{ before(grammarAccess.getTableAllColumnsRule()); }
+	 ruleTableAllColumns
+{ after(grammarAccess.getTableAllColumnsRule()); } 
+	 EOF 
+;
+
+// Rule TableAllColumns
+ruleTableAllColumns
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableAllColumnsAccess().getGroup()); }
+(rule__TableAllColumns__Group__0)
+{ after(grammarAccess.getTableAllColumnsAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableOrdinal
+entryRuleTableOrdinal 
+:
+{ before(grammarAccess.getTableOrdinalRule()); }
+	 ruleTableOrdinal
+{ after(grammarAccess.getTableOrdinalRule()); } 
+	 EOF 
+;
+
+// Rule TableOrdinal
+ruleTableOrdinal
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableOrdinalAccess().getGroup()); }
+(rule__TableOrdinal__Group__0)
+{ after(grammarAccess.getTableOrdinalAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableColumn
+entryRuleTableColumn 
+:
+{ before(grammarAccess.getTableColumnRule()); }
+	 ruleTableColumn
+{ after(grammarAccess.getTableColumnRule()); } 
+	 EOF 
+;
+
+// Rule TableColumn
+ruleTableColumn
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableColumnAccess().getGroup()); }
+(rule__TableColumn__Group__0)
+{ after(grammarAccess.getTableColumnAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableMeasure
+entryRuleTableMeasure 
+:
+{ before(grammarAccess.getTableMeasureRule()); }
+	 ruleTableMeasure
+{ after(grammarAccess.getTableMeasureRule()); } 
+	 EOF 
+;
+
+// Rule TableMeasure
+ruleTableMeasure
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableMeasureAccess().getGroup()); }
+(rule__TableMeasure__Group__0)
+{ after(grammarAccess.getTableMeasureAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDerived
+entryRuleTableDerived 
+:
+{ before(grammarAccess.getTableDerivedRule()); }
+	 ruleTableDerived
+{ after(grammarAccess.getTableDerivedRule()); } 
+	 EOF 
+;
+
+// Rule TableDerived
+ruleTableDerived
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableDerivedAccess().getGroup()); }
+(rule__TableDerived__Group__0)
+{ after(grammarAccess.getTableDerivedAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableHierarchy
+entryRuleTableHierarchy 
+:
+{ before(grammarAccess.getTableHierarchyRule()); }
+	 ruleTableHierarchy
+{ after(grammarAccess.getTableHierarchyRule()); } 
+	 EOF 
+;
+
+// Rule TableHierarchy
+ruleTableHierarchy
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableHierarchyAccess().getGroup()); }
+(rule__TableHierarchy__Group__0)
+{ after(grammarAccess.getTableHierarchyAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableProperty
+entryRuleTableProperty 
+:
+{ before(grammarAccess.getTablePropertyRule()); }
+	 ruleTableProperty
+{ after(grammarAccess.getTablePropertyRule()); } 
+	 EOF 
+;
+
+// Rule TableProperty
+ruleTableProperty
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTablePropertyAccess().getGroup()); }
+(rule__TableProperty__Group__0)
+{ after(grammarAccess.getTablePropertyAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableAggregation
+entryRuleTableAggregation 
+:
+{ before(grammarAccess.getTableAggregationRule()); }
+	 ruleTableAggregation
+{ after(grammarAccess.getTableAggregationRule()); } 
+	 EOF 
+;
+
+// Rule TableAggregation
+ruleTableAggregation
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableAggregationAccess().getGroup()); }
+(rule__TableAggregation__Group__0)
+{ after(grammarAccess.getTableAggregationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableInterval
+entryRuleTableInterval 
+:
+{ before(grammarAccess.getTableIntervalRule()); }
+	 ruleTableInterval
+{ after(grammarAccess.getTableIntervalRule()); } 
+	 EOF 
+;
+
+// Rule TableInterval
+ruleTableInterval
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableIntervalAccess().getAlternatives()); }
+(rule__TableInterval__Alternatives)
+{ after(grammarAccess.getTableIntervalAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableNumberInterval
+entryRuleTableNumberInterval 
+:
+{ before(grammarAccess.getTableNumberIntervalRule()); }
+	 ruleTableNumberInterval
+{ after(grammarAccess.getTableNumberIntervalRule()); } 
+	 EOF 
+;
+
+// Rule TableNumberInterval
+ruleTableNumberInterval
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getGroup()); }
+(rule__TableNumberInterval__Group__0)
+{ after(grammarAccess.getTableNumberIntervalAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDateDayInterval
+entryRuleTableDateDayInterval 
+:
+{ before(grammarAccess.getTableDateDayIntervalRule()); }
+	 ruleTableDateDayInterval
+{ after(grammarAccess.getTableDateDayIntervalRule()); } 
+	 EOF 
+;
+
+// Rule TableDateDayInterval
+ruleTableDateDayInterval
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getGroup()); }
+(rule__TableDateDayInterval__Group__0)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableLookup
+entryRuleTableLookup 
+:
+{ before(grammarAccess.getTableLookupRule()); }
+	 ruleTableLookup
+{ after(grammarAccess.getTableLookupRule()); } 
+	 EOF 
+;
+
+// Rule TableLookup
+ruleTableLookup
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableLookupAccess().getAlternatives()); }
+(rule__TableLookup__Alternatives)
+{ after(grammarAccess.getTableLookupAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableNumberLookup
+entryRuleTableNumberLookup 
+:
+{ before(grammarAccess.getTableNumberLookupRule()); }
+	 ruleTableNumberLookup
+{ after(grammarAccess.getTableNumberLookupRule()); } 
+	 EOF 
+;
+
+// Rule TableNumberLookup
+ruleTableNumberLookup
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getGroup()); }
+(rule__TableNumberLookup__Group__0)
+{ after(grammarAccess.getTableNumberLookupAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableStringLookup
+entryRuleTableStringLookup 
+:
+{ before(grammarAccess.getTableStringLookupRule()); }
+	 ruleTableStringLookup
+{ after(grammarAccess.getTableStringLookupRule()); } 
+	 EOF 
+;
+
+// Rule TableStringLookup
+ruleTableStringLookup
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getGroup()); }
+(rule__TableStringLookup__Group__0)
+{ after(grammarAccess.getTableStringLookupAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDateDayLookup
+entryRuleTableDateDayLookup 
+:
+{ before(grammarAccess.getTableDateDayLookupRule()); }
+	 ruleTableDateDayLookup
+{ after(grammarAccess.getTableDateDayLookupRule()); } 
+	 EOF 
+;
+
+// Rule TableDateDayLookup
+ruleTableDateDayLookup
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getGroup()); }
+(rule__TableDateDayLookup__Group__0)
+{ after(grammarAccess.getTableDateDayLookupAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDatamart
+entryRuleTableDatamart 
+:
+{ before(grammarAccess.getTableDatamartRule()); }
+	 ruleTableDatamart
+{ after(grammarAccess.getTableDatamartRule()); } 
+	 EOF 
+;
+
+// Rule TableDatamart
+ruleTableDatamart
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableDatamartAccess().getGroup()); }
+(rule__TableDatamart__Group__0)
+{ after(grammarAccess.getTableDatamartAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableElement
+entryRuleTableElement 
+:
+{ before(grammarAccess.getTableElementRule()); }
+	 ruleTableElement
+{ after(grammarAccess.getTableElementRule()); } 
+	 EOF 
+;
+
+// Rule TableElement
+ruleTableElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableElementAccess().getTableAxisParserRuleCall()); }
+	ruleTableAxis
+{ after(grammarAccess.getTableElementAccess().getTableAxisParserRuleCall()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableEvent
+entryRuleTableEvent 
+:
+{ before(grammarAccess.getTableEventRule()); }
+	 ruleTableEvent
+{ after(grammarAccess.getTableEventRule()); } 
+	 EOF 
+;
+
+// Rule TableEvent
+ruleTableEvent
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableEventAccess().getGroup()); }
+(rule__TableEvent__Group__0)
+{ after(grammarAccess.getTableEventAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableBrokerDatamart
+entryRuleTableBrokerDatamart 
+:
+{ before(grammarAccess.getTableBrokerDatamartRule()); }
+	 ruleTableBrokerDatamart
+{ after(grammarAccess.getTableBrokerDatamartRule()); } 
+	 EOF 
+;
+
+// Rule TableBrokerDatamart
+ruleTableBrokerDatamart
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableBrokerDatamartAccess().getGroup()); }
+(rule__TableBrokerDatamart__Group__0)
+{ after(grammarAccess.getTableBrokerDatamartAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableAxis
+entryRuleTableAxis 
+:
+{ before(grammarAccess.getTableAxisRule()); }
+	 ruleTableAxis
+{ after(grammarAccess.getTableAxisRule()); } 
+	 EOF 
+;
+
+// Rule TableAxis
+ruleTableAxis
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableAxisAccess().getGroup()); }
+(rule__TableAxis__Group__0)
+{ after(grammarAccess.getTableAxisAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableRangeElement
+entryRuleTableRangeElement 
+:
+{ before(grammarAccess.getTableRangeElementRule()); }
+	 ruleTableRangeElement
+{ after(grammarAccess.getTableRangeElementRule()); } 
+	 EOF 
+;
+
+// Rule TableRangeElement
+ruleTableRangeElement
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableRangeElementAccess().getAlternatives()); }
+(rule__TableRangeElement__Alternatives)
+{ after(grammarAccess.getTableRangeElementAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTextColor
+entryRuleTableTextColor 
+:
+{ before(grammarAccess.getTableTextColorRule()); }
+	 ruleTableTextColor
+{ after(grammarAccess.getTableTextColorRule()); } 
+	 EOF 
+;
+
+// Rule TableTextColor
+ruleTableTextColor
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableTextColorAccess().getGroup()); }
+(rule__TableTextColor__Group__0)
+{ after(grammarAccess.getTableTextColorAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableCellColor
+entryRuleTableCellColor 
+:
+{ before(grammarAccess.getTableCellColorRule()); }
+	 ruleTableCellColor
+{ after(grammarAccess.getTableCellColorRule()); } 
+	 EOF 
+;
+
+// Rule TableCellColor
+ruleTableCellColor
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableCellColorAccess().getGroup()); }
+(rule__TableCellColor__Group__0)
+{ after(grammarAccess.getTableCellColorAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableIcon
+entryRuleTableIcon 
+:
+{ before(grammarAccess.getTableIconRule()); }
+	 ruleTableIcon
+{ after(grammarAccess.getTableIconRule()); } 
+	 EOF 
+;
+
+// Rule TableIcon
+ruleTableIcon
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableIconAccess().getGroup()); }
+(rule__TableIcon__Group__0)
+{ after(grammarAccess.getTableIconAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTrend
+entryRuleTableTrend 
+:
+{ before(grammarAccess.getTableTrendRule()); }
+	 ruleTableTrend
+{ after(grammarAccess.getTableTrendRule()); } 
+	 EOF 
+;
+
+// Rule TableTrend
+ruleTableTrend
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableTrendAccess().getGroup()); }
+(rule__TableTrend__Group__0)
+{ after(grammarAccess.getTableTrendAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableTooltip
+entryRuleTableTooltip 
+:
+{ before(grammarAccess.getTableTooltipRule()); }
+	 ruleTableTooltip
+{ after(grammarAccess.getTableTooltipRule()); } 
+	 EOF 
+;
+
+// Rule TableTooltip
+ruleTableTooltip
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableTooltipAccess().getGroup()); }
+(rule__TableTooltip__Group__0)
+{ after(grammarAccess.getTableTooltipAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableImport
+entryRuleTableImport 
+:
+{ before(grammarAccess.getTableImportRule()); }
+	 ruleTableImport
+{ after(grammarAccess.getTableImportRule()); } 
+	 EOF 
+;
+
+// Rule TableImport
+ruleTableImport
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableImportAccess().getGroup()); }
+(rule__TableImport__Group__0)
+{ after(grammarAccess.getTableImportAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableGrid
+entryRuleTableGrid 
+:
+{ before(grammarAccess.getTableGridRule()); }
+	 ruleTableGrid
+{ after(grammarAccess.getTableGridRule()); } 
+	 EOF 
+;
+
+// Rule TableGrid
+ruleTableGrid
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableGridAccess().getGroup()); }
+(rule__TableGrid__Group__0)
+{ after(grammarAccess.getTableGridAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableDtoDatasource
+entryRuleTableDtoDatasource 
+:
+{ before(grammarAccess.getTableDtoDatasourceRule()); }
+	 ruleTableDtoDatasource
+{ after(grammarAccess.getTableDtoDatasourceRule()); } 
+	 EOF 
+;
+
+// Rule TableDtoDatasource
+ruleTableDtoDatasource
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableDtoDatasourceAccess().getGroup()); }
+(rule__TableDtoDatasource__Group__0)
+{ after(grammarAccess.getTableDtoDatasourceAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleProperty
+entryRuleProperty 
+:
+{ before(grammarAccess.getPropertyRule()); }
+	 ruleProperty
+{ after(grammarAccess.getPropertyRule()); } 
+	 EOF 
+;
+
+// Rule Property
+ruleProperty
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyAccess().getGroup()); }
+(rule__Property__Group__0)
+{ after(grammarAccess.getPropertyAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNestedField
+entryRuleNestedField 
+:
+{ before(grammarAccess.getNestedFieldRule()); }
+	 ruleNestedField
+{ after(grammarAccess.getNestedFieldRule()); } 
+	 EOF 
+;
+
+// Rule NestedField
+ruleNestedField
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNestedFieldAccess().getGroup()); }
+(rule__NestedField__Group__0)
+{ after(grammarAccess.getNestedFieldAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNestedPath
+entryRuleNestedPath 
+:
+{ before(grammarAccess.getNestedPathRule()); }
+	 ruleNestedPath
+{ after(grammarAccess.getNestedPathRule()); } 
+	 EOF 
+;
+
+// Rule NestedPath
+ruleNestedPath
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNestedPathAccess().getGroup()); }
+(rule__NestedPath__Group__0)
+{ after(grammarAccess.getNestedPathAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyStyle
+entryRulePropertyStyle 
+:
+{ before(grammarAccess.getPropertyStyleRule()); }
+	 rulePropertyStyle
+{ after(grammarAccess.getPropertyStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyStyle
+rulePropertyStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyStyleAccess().getAlternatives()); }
+(rule__PropertyStyle__Alternatives)
+{ after(grammarAccess.getPropertyStyleAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyButtonStyle
+entryRulePropertyButtonStyle 
+:
+{ before(grammarAccess.getPropertyButtonStyleRule()); }
+	 rulePropertyButtonStyle
+{ after(grammarAccess.getPropertyButtonStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyButtonStyle
+rulePropertyButtonStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyButtonStyleAccess().getGroup()); }
+(rule__PropertyButtonStyle__Group__0)
+{ after(grammarAccess.getPropertyButtonStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyHtmlStyle
+entryRulePropertyHtmlStyle 
+:
+{ before(grammarAccess.getPropertyHtmlStyleRule()); }
+	 rulePropertyHtmlStyle
+{ after(grammarAccess.getPropertyHtmlStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyHtmlStyle
+rulePropertyHtmlStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyHtmlStyleAccess().getGroup()); }
+(rule__PropertyHtmlStyle__Group__0)
+{ after(grammarAccess.getPropertyHtmlStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyBooleanStyle
+entryRulePropertyBooleanStyle 
+:
+{ before(grammarAccess.getPropertyBooleanStyleRule()); }
+	 rulePropertyBooleanStyle
+{ after(grammarAccess.getPropertyBooleanStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyBooleanStyle
+rulePropertyBooleanStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyBooleanStyleAccess().getGroup()); }
+(rule__PropertyBooleanStyle__Group__0)
+{ after(grammarAccess.getPropertyBooleanStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyDateStyle
+entryRulePropertyDateStyle 
+:
+{ before(grammarAccess.getPropertyDateStyleRule()); }
+	 rulePropertyDateStyle
+{ after(grammarAccess.getPropertyDateStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyDateStyle
+rulePropertyDateStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyDateStyleAccess().getGroup()); }
+(rule__PropertyDateStyle__Group__0)
+{ after(grammarAccess.getPropertyDateStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyNumberStyle
+entryRulePropertyNumberStyle 
+:
+{ before(grammarAccess.getPropertyNumberStyleRule()); }
+	 rulePropertyNumberStyle
+{ after(grammarAccess.getPropertyNumberStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyNumberStyle
+rulePropertyNumberStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyNumberStyleAccess().getGroup()); }
+(rule__PropertyNumberStyle__Group__0)
+{ after(grammarAccess.getPropertyNumberStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyProgressbarStyle
+entryRulePropertyProgressbarStyle 
+:
+{ before(grammarAccess.getPropertyProgressbarStyleRule()); }
+	 rulePropertyProgressbarStyle
+{ after(grammarAccess.getPropertyProgressbarStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyProgressbarStyle
+rulePropertyProgressbarStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyProgressbarStyleAccess().getGroup()); }
+(rule__PropertyProgressbarStyle__Group__0)
+{ after(grammarAccess.getPropertyProgressbarStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleGridPropIndicatorStyle
+entryRuleGridPropIndicatorStyle 
+:
+{ before(grammarAccess.getGridPropIndicatorStyleRule()); }
+	 ruleGridPropIndicatorStyle
+{ after(grammarAccess.getGridPropIndicatorStyleRule()); } 
+	 EOF 
+;
+
+// Rule GridPropIndicatorStyle
+ruleGridPropIndicatorStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getGridPropIndicatorStyleAccess().getGroup()); }
+(rule__GridPropIndicatorStyle__Group__0)
+{ after(grammarAccess.getGridPropIndicatorStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyQuantityStyle
+entryRulePropertyQuantityStyle 
+:
+{ before(grammarAccess.getPropertyQuantityStyleRule()); }
+	 rulePropertyQuantityStyle
+{ after(grammarAccess.getPropertyQuantityStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyQuantityStyle
+rulePropertyQuantityStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyQuantityStyleAccess().getGroup()); }
+(rule__PropertyQuantityStyle__Group__0)
+{ after(grammarAccess.getPropertyQuantityStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyPriceStyle
+entryRulePropertyPriceStyle 
+:
+{ before(grammarAccess.getPropertyPriceStyleRule()); }
+	 rulePropertyPriceStyle
+{ after(grammarAccess.getPropertyPriceStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyPriceStyle
+rulePropertyPriceStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyPriceStyleAccess().getGroup()); }
+(rule__PropertyPriceStyle__Group__0)
+{ after(grammarAccess.getPropertyPriceStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyTextStyle
+entryRulePropertyTextStyle 
+:
+{ before(grammarAccess.getPropertyTextStyleRule()); }
+	 rulePropertyTextStyle
+{ after(grammarAccess.getPropertyTextStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyTextStyle
+rulePropertyTextStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyTextStyleAccess().getGroup()); }
+(rule__PropertyTextStyle__Group__0)
+{ after(grammarAccess.getPropertyTextStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRulePropertyImageStyle
+entryRulePropertyImageStyle 
+:
+{ before(grammarAccess.getPropertyImageStyleRule()); }
+	 rulePropertyImageStyle
+{ after(grammarAccess.getPropertyImageStyleRule()); } 
+	 EOF 
+;
+
+// Rule PropertyImageStyle
+rulePropertyImageStyle
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getPropertyImageStyleAccess().getGroup()); }
+(rule__PropertyImageStyle__Group__0)
+{ after(grammarAccess.getPropertyImageStyleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStyleConfig
+entryRuleStyleConfig 
+:
+{ before(grammarAccess.getStyleConfigRule()); }
+	 ruleStyleConfig
+{ after(grammarAccess.getStyleConfigRule()); } 
+	 EOF 
+;
+
+// Rule StyleConfig
+ruleStyleConfig
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getStyleConfigAccess().getAlternatives()); }
+(rule__StyleConfig__Alternatives)
+{ after(grammarAccess.getStyleConfigAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleNumericToResourceStyleConfig
+entryRuleNumericToResourceStyleConfig 
+:
+{ before(grammarAccess.getNumericToResourceStyleConfigRule()); }
+	 ruleNumericToResourceStyleConfig
+{ after(grammarAccess.getNumericToResourceStyleConfigRule()); } 
+	 EOF 
+;
+
+// Rule NumericToResourceStyleConfig
+ruleNumericToResourceStyleConfig
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getNumericToResourceStyleConfigAccess().getGroup()); }
+(rule__NumericToResourceStyleConfig__Group__0)
+{ after(grammarAccess.getNumericToResourceStyleConfigAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleStringToResourceStyleConfig
+entryRuleStringToResourceStyleConfig 
+:
+{ before(grammarAccess.getStringToResourceStyleConfigRule()); }
+	 ruleStringToResourceStyleConfig
+{ after(grammarAccess.getStringToResourceStyleConfigRule()); } 
+	 EOF 
+;
+
+// Rule StringToResourceStyleConfig
+ruleStringToResourceStyleConfig
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getStringToResourceStyleConfigAccess().getGroup()); }
+(rule__StringToResourceStyleConfig__Group__0)
+{ after(grammarAccess.getStringToResourceStyleConfigAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLInt
+entryRuleLInt 
+:
+{ before(grammarAccess.getLIntRule()); }
+	 ruleLInt
+{ after(grammarAccess.getLIntRule()); } 
+	 EOF 
+;
+
+// Rule LInt
+ruleLInt
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLIntAccess().getGroup()); }
+(rule__LInt__Group__0)
+{ after(grammarAccess.getLIntAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleLDouble
+entryRuleLDouble 
+:
+{ before(grammarAccess.getLDoubleRule()); }
+	 ruleLDouble
+{ after(grammarAccess.getLDoubleRule()); } 
+	 EOF 
+;
+
+// Rule LDouble
+ruleLDouble
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getLDoubleAccess().getGroup()); }
+(rule__LDouble__Group__0)
+{ after(grammarAccess.getLDoubleAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleSignedNumber
+entryRuleSignedNumber 
+:
+{ before(grammarAccess.getSignedNumberRule()); }
+	 ruleSignedNumber
+{ after(grammarAccess.getSignedNumberRule()); } 
+	 EOF 
+;
+
+// Rule SignedNumber
+ruleSignedNumber
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getSignedNumberAccess().getGroup()); }
+(rule__SignedNumber__Group__0)
+{ after(grammarAccess.getSignedNumberAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTableQualifiedNameWithWildCard
+entryRuleTableQualifiedNameWithWildCard 
+:
+{ before(grammarAccess.getTableQualifiedNameWithWildCardRule()); }
+	 ruleTableQualifiedNameWithWildCard
+{ after(grammarAccess.getTableQualifiedNameWithWildCardRule()); } 
+	 EOF 
+;
+
+// Rule TableQualifiedNameWithWildCard
+ruleTableQualifiedNameWithWildCard
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTableQualifiedNameWithWildCardAccess().getGroup()); }
+(rule__TableQualifiedNameWithWildCard__Group__0)
+{ after(grammarAccess.getTableQualifiedNameWithWildCardAccess().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 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 entryRuleTRANSLATABLESTRING
+entryRuleTRANSLATABLESTRING 
+:
+{ before(grammarAccess.getTRANSLATABLESTRINGRule()); }
+	 ruleTRANSLATABLESTRING
+{ after(grammarAccess.getTRANSLATABLESTRINGRule()); } 
+	 EOF 
+;
+
+// Rule TRANSLATABLESTRING
+ruleTRANSLATABLESTRING
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall()); }
+	RULE_STRING
+{ after(grammarAccess.getTRANSLATABLESTRINGAccess().getSTRINGTerminalRuleCall()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleTRANSLATABLEID
+entryRuleTRANSLATABLEID 
+:
+{ before(grammarAccess.getTRANSLATABLEIDRule()); }
+	 ruleTRANSLATABLEID
+{ after(grammarAccess.getTRANSLATABLEIDRule()); } 
+	 EOF 
+;
+
+// Rule TRANSLATABLEID
+ruleTRANSLATABLEID
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall()); }
+	RULE_ID
+{ after(grammarAccess.getTRANSLATABLEIDAccess().getIDTerminalRuleCall()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule 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 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 entryRuleXImportDeclaration
+entryRuleXImportDeclaration 
+:
+{ before(grammarAccess.getXImportDeclarationRule()); }
+	 ruleXImportDeclaration
+{ after(grammarAccess.getXImportDeclarationRule()); } 
+	 EOF 
+;
+
+// Rule XImportDeclaration
+ruleXImportDeclaration
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+{ before(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+(rule__XImportDeclaration__Group__0)
+{ after(grammarAccess.getXImportDeclarationAccess().getGroup()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Entry rule entryRuleQualifiedNameInStaticImport
+entryRuleQualifiedNameInStaticImport 
+:
+{ before(grammarAccess.getQualifiedNameInStaticImportRule()); }
+	 ruleQualifiedNameInStaticImport
+{ after(grammarAccess.getQualifiedNameInStaticImportRule()); } 
+	 EOF 
+;
+
+// Rule QualifiedNameInStaticImport
+ruleQualifiedNameInStaticImport
+    @init {
+		int stackSize = keepStackSize();
+    }
+	:
+(
+(
+{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+(rule__QualifiedNameInStaticImport__Group__0)
+{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+)
+(
+{ before(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+(rule__QualifiedNameInStaticImport__Group__0)*
+{ after(grammarAccess.getQualifiedNameInStaticImportAccess().getGroup()); }
+)
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+// Rule StyleCompare
+ruleStyleCompare
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getStyleCompareAccess().getAlternatives()); }
+(rule__StyleCompare__Alternatives)
+{ after(grammarAccess.getStyleCompareAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule TrendIconEnum
+ruleTrendIconEnum
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTrendIconEnumAccess().getAlternatives()); }
+(rule__TrendIconEnum__Alternatives)
+{ after(grammarAccess.getTrendIconEnumAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule RowHeaderMode
+ruleRowHeaderMode
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRowHeaderModeAccess().getAlternatives()); }
+(rule__RowHeaderMode__Alternatives)
+{ after(grammarAccess.getRowHeaderModeAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+// Rule AxisEnum
+ruleAxisEnum
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAxisEnumAccess().getAlternatives()); }
+(rule__AxisEnum__Alternatives)
+{ after(grammarAccess.getAxisEnumAccess().getAlternatives()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+rule__TableOption__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableOptionAccess().getTableSelectionParserRuleCall_0()); }
+	ruleTableSelection
+{ after(grammarAccess.getTableOptionAccess().getTableSelectionParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableOptionAccess().getTableTableParserRuleCall_1()); }
+	ruleTableTable
+{ after(grammarAccess.getTableOptionAccess().getTableTableParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getTableOptionAccess().getTableGridParserRuleCall_2()); }
+	ruleTableGrid
+{ after(grammarAccess.getTableOptionAccess().getTableGridParserRuleCall_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Alternatives_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getMultiSelectionAssignment_1_0()); }
+(rule__TableSelection__MultiSelectionAssignment_1_0)
+{ after(grammarAccess.getTableSelectionAccess().getMultiSelectionAssignment_1_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableSelectionAccess().getSingleselectionKeyword_1_1()); }
+
+	'singleselection' 
+
+{ after(grammarAccess.getTableSelectionAccess().getSingleselectionKeyword_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValueElement__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueElementAccess().getTableMeasureParserRuleCall_0()); }
+	ruleTableMeasure
+{ after(grammarAccess.getTableValueElementAccess().getTableMeasureParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableDerivedParserRuleCall_1()); }
+	ruleTableDerived
+{ after(grammarAccess.getTableValueElementAccess().getTableDerivedParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableHierarchyParserRuleCall_2()); }
+	ruleTableHierarchy
+{ after(grammarAccess.getTableValueElementAccess().getTableHierarchyParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTablePropertyParserRuleCall_3()); }
+	ruleTableProperty
+{ after(grammarAccess.getTableValueElementAccess().getTablePropertyParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableAggregationParserRuleCall_4()); }
+	ruleTableAggregation
+{ after(grammarAccess.getTableValueElementAccess().getTableAggregationParserRuleCall_4()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableOrdinalParserRuleCall_5()); }
+	ruleTableOrdinal
+{ after(grammarAccess.getTableValueElementAccess().getTableOrdinalParserRuleCall_5()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableColumnParserRuleCall_6()); }
+	ruleTableColumn
+{ after(grammarAccess.getTableValueElementAccess().getTableColumnParserRuleCall_6()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableTaskParserRuleCall_7()); }
+	ruleTableTask
+{ after(grammarAccess.getTableValueElementAccess().getTableTaskParserRuleCall_7()); }
+)
+
+    |(
+{ before(grammarAccess.getTableValueElementAccess().getTableAllColumnsParserRuleCall_8()); }
+	ruleTableAllColumns
+{ after(grammarAccess.getTableValueElementAccess().getTableAllColumnsParserRuleCall_8()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableInterval__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableIntervalAccess().getTableNumberIntervalParserRuleCall_0()); }
+	ruleTableNumberInterval
+{ after(grammarAccess.getTableIntervalAccess().getTableNumberIntervalParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableIntervalAccess().getTableDateDayIntervalParserRuleCall_1()); }
+	ruleTableDateDayInterval
+{ after(grammarAccess.getTableIntervalAccess().getTableDateDayIntervalParserRuleCall_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableLookup__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableLookupAccess().getTableNumberLookupParserRuleCall_0()); }
+	ruleTableNumberLookup
+{ after(grammarAccess.getTableLookupAccess().getTableNumberLookupParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableLookupAccess().getTableStringLookupParserRuleCall_1()); }
+	ruleTableStringLookup
+{ after(grammarAccess.getTableLookupAccess().getTableStringLookupParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getTableLookupAccess().getTableDateDayLookupParserRuleCall_2()); }
+	ruleTableDateDayLookup
+{ after(grammarAccess.getTableLookupAccess().getTableDateDayLookupParserRuleCall_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableBrokerDatamart__Alternatives_2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_0()); }
+(rule__TableBrokerDatamart__Group_2_0__0)
+{ after(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_1()); }
+(rule__TableBrokerDatamart__Group_2_1__0)
+{ after(grammarAccess.getTableBrokerDatamartAccess().getGroup_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableRangeElement__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableRangeElementAccess().getTableTextColorParserRuleCall_0()); }
+	ruleTableTextColor
+{ after(grammarAccess.getTableRangeElementAccess().getTableTextColorParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableCellColorParserRuleCall_1()); }
+	ruleTableCellColor
+{ after(grammarAccess.getTableRangeElementAccess().getTableCellColorParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableIconParserRuleCall_2()); }
+	ruleTableIcon
+{ after(grammarAccess.getTableRangeElementAccess().getTableIconParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableTrendParserRuleCall_3()); }
+	ruleTableTrend
+{ after(grammarAccess.getTableRangeElementAccess().getTableTrendParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getTableRangeElementAccess().getTableTooltipParserRuleCall_4()); }
+	ruleTableTooltip
+{ after(grammarAccess.getTableRangeElementAccess().getTableTooltipParserRuleCall_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__PropertyStyle__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0()); }
+	rulePropertyButtonStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyButtonStyleParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1()); }
+	rulePropertyHtmlStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyHtmlStyleParserRuleCall_1()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2()); }
+	rulePropertyProgressbarStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyProgressbarStyleParserRuleCall_2()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3()); }
+	rulePropertyTextStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyTextStyleParserRuleCall_3()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4()); }
+	rulePropertyBooleanStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyBooleanStyleParserRuleCall_4()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5()); }
+	rulePropertyDateStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyDateStyleParserRuleCall_5()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6()); }
+	rulePropertyNumberStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyNumberStyleParserRuleCall_6()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7()); }
+	rulePropertyImageStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyImageStyleParserRuleCall_7()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8()); }
+	rulePropertyQuantityStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyQuantityStyleParserRuleCall_8()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9()); }
+	rulePropertyPriceStyle
+{ after(grammarAccess.getPropertyStyleAccess().getPropertyPriceStyleParserRuleCall_9()); }
+)
+
+    |(
+{ before(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10()); }
+	ruleGridPropIndicatorStyle
+{ after(grammarAccess.getPropertyStyleAccess().getGridPropIndicatorStyleParserRuleCall_10()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__StyleConfig__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0()); }
+	ruleNumericToResourceStyleConfig
+{ after(grammarAccess.getStyleConfigAccess().getNumericToResourceStyleConfigParserRuleCall_0()); }
+)
+
+    |(
+{ before(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1()); }
+	ruleStringToResourceStyleConfig
+{ after(grammarAccess.getStyleConfigAccess().getStringToResourceStyleConfigParserRuleCall_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__LInt__Alternatives_0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getLIntAccess().getPlusSignKeyword_0_0()); }
+
+	'+' 
+
+{ after(grammarAccess.getLIntAccess().getPlusSignKeyword_0_0()); }
+)
+
+    |(
+{ before(grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_1()); }
+
+	'-' 
+
+{ after(grammarAccess.getLIntAccess().getHyphenMinusKeyword_0_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__Alternatives_1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); }
+(rule__XImportDeclaration__Group_1_0__0)
+{ after(grammarAccess.getXImportDeclarationAccess().getGroup_1_0()); }
+)
+
+    |(
+{ before(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); }
+(rule__XImportDeclaration__ImportedTypeAssignment_1_1)
+{ after(grammarAccess.getXImportDeclarationAccess().getImportedTypeAssignment_1_1()); }
+)
+
+    |(
+{ before(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); }
+(rule__XImportDeclaration__ImportedNamespaceAssignment_1_2)
+{ after(grammarAccess.getXImportDeclarationAccess().getImportedNamespaceAssignment_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__XImportDeclaration__Alternatives_1_0_3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); }
+(rule__XImportDeclaration__WildcardAssignment_1_0_3_0)
+{ after(grammarAccess.getXImportDeclarationAccess().getWildcardAssignment_1_0_3_0()); }
+)
+
+    |(
+{ before(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); }
+(rule__XImportDeclaration__MemberNameAssignment_1_0_3_1)
+{ after(grammarAccess.getXImportDeclarationAccess().getMemberNameAssignment_1_0_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__StyleCompare__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getStyleCompareAccess().getEqualEnumLiteralDeclaration_0()); }
+(	'equal' 
+)
+{ after(grammarAccess.getStyleCompareAccess().getEqualEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getStyleCompareAccess().getGreaterEqualEnumLiteralDeclaration_1()); }
+(	'greater equal' 
+)
+{ after(grammarAccess.getStyleCompareAccess().getGreaterEqualEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getStyleCompareAccess().getGreaterThanEnumLiteralDeclaration_2()); }
+(	'greater than' 
+)
+{ after(grammarAccess.getStyleCompareAccess().getGreaterThanEnumLiteralDeclaration_2()); }
+)
+
+    |(
+{ before(grammarAccess.getStyleCompareAccess().getLowerEqualEnumLiteralDeclaration_3()); }
+(	'lower equal' 
+)
+{ after(grammarAccess.getStyleCompareAccess().getLowerEqualEnumLiteralDeclaration_3()); }
+)
+
+    |(
+{ before(grammarAccess.getStyleCompareAccess().getLowerThanEnumLiteralDeclaration_4()); }
+(	'lower than' 
+)
+{ after(grammarAccess.getStyleCompareAccess().getLowerThanEnumLiteralDeclaration_4()); }
+)
+
+    |(
+{ before(grammarAccess.getStyleCompareAccess().getNotEqualEnumLiteralDeclaration_5()); }
+(	'not equal' 
+)
+{ after(grammarAccess.getStyleCompareAccess().getNotEqualEnumLiteralDeclaration_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TrendIconEnum__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTrendIconEnumAccess().getRISINGEnumLiteralDeclaration_0()); }
+(	'rising' 
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getRISINGEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getTrendIconEnumAccess().getBADRISINGEnumLiteralDeclaration_1()); }
+(	'bad-rising' 
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getBADRISINGEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getTrendIconEnumAccess().getSLOPINGEnumLiteralDeclaration_2()); }
+(	'sloping' 
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getSLOPINGEnumLiteralDeclaration_2()); }
+)
+
+    |(
+{ before(grammarAccess.getTrendIconEnumAccess().getGOODSLOPINGEnumLiteralDeclaration_3()); }
+(	'good-sloping' 
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getGOODSLOPINGEnumLiteralDeclaration_3()); }
+)
+
+    |(
+{ before(grammarAccess.getTrendIconEnumAccess().getSTAGNATINGEnumLiteralDeclaration_4()); }
+(	'stagnating' 
+)
+{ after(grammarAccess.getTrendIconEnumAccess().getSTAGNATINGEnumLiteralDeclaration_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__RowHeaderMode__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getRowHeaderModeAccess().getHIDDENEnumLiteralDeclaration_0()); }
+(	'hidden' 
+)
+{ after(grammarAccess.getRowHeaderModeAccess().getHIDDENEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getRowHeaderModeAccess().getEXPLICIT_DEFAULTS_IDEnumLiteralDeclaration_1()); }
+(	'explicit' 
+)
+{ after(grammarAccess.getRowHeaderModeAccess().getEXPLICIT_DEFAULTS_IDEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getRowHeaderModeAccess().getINDEXEnumLiteralDeclaration_2()); }
+(	'indexed' 
+)
+{ after(grammarAccess.getRowHeaderModeAccess().getINDEXEnumLiteralDeclaration_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__AxisEnum__Alternatives
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getAxisEnumAccess().getDEFAULTEnumLiteralDeclaration_0()); }
+(	'default' 
+)
+{ after(grammarAccess.getAxisEnumAccess().getDEFAULTEnumLiteralDeclaration_0()); }
+)
+
+    |(
+{ before(grammarAccess.getAxisEnumAccess().getCOLUMNSEnumLiteralDeclaration_1()); }
+(	'columns' 
+)
+{ after(grammarAccess.getAxisEnumAccess().getCOLUMNSEnumLiteralDeclaration_1()); }
+)
+
+    |(
+{ before(grammarAccess.getAxisEnumAccess().getROWSEnumLiteralDeclaration_2()); }
+(	'rows' 
+)
+{ after(grammarAccess.getAxisEnumAccess().getROWSEnumLiteralDeclaration_2()); }
+)
+
+    |(
+{ before(grammarAccess.getAxisEnumAccess().getPAGESEnumLiteralDeclaration_3()); }
+(	'pages' 
+)
+{ after(grammarAccess.getAxisEnumAccess().getPAGESEnumLiteralDeclaration_3()); }
+)
+
+    |(
+{ before(grammarAccess.getAxisEnumAccess().getSECTIONSEnumLiteralDeclaration_4()); }
+(	'sections' 
+)
+{ after(grammarAccess.getAxisEnumAccess().getSECTIONSEnumLiteralDeclaration_4()); }
+)
+
+    |(
+{ before(grammarAccess.getAxisEnumAccess().getCHAPTERSEnumLiteralDeclaration_5()); }
+(	'chapters' 
+)
+{ after(grammarAccess.getAxisEnumAccess().getCHAPTERSEnumLiteralDeclaration_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+rule__TablePackage__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group__0__Impl
+	rule__TablePackage__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getTablePackageAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTablePackageAccess().getTablePackageAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group__1__Impl
+	rule__TablePackage__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getPackageKeyword_1()); }
+
+	'package' 
+
+{ after(grammarAccess.getTablePackageAccess().getPackageKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group__2__Impl
+	rule__TablePackage__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getNameAssignment_2()); }
+(rule__TablePackage__NameAssignment_2)
+{ after(grammarAccess.getTablePackageAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getGroup_3()); }
+(rule__TablePackage__Group_3__0)?
+{ after(grammarAccess.getTablePackageAccess().getGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TablePackage__Group_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group_3__0__Impl
+	rule__TablePackage__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getLeftCurlyBracketKeyword_3_0()); }
+
+	'{' 
+
+{ after(grammarAccess.getTablePackageAccess().getLeftCurlyBracketKeyword_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group_3__1__Impl
+	rule__TablePackage__Group_3__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getImportsAssignment_3_1()); }
+(rule__TablePackage__ImportsAssignment_3_1)*
+{ after(grammarAccess.getTablePackageAccess().getImportsAssignment_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group_3__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group_3__2__Impl
+	rule__TablePackage__Group_3__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getTablesAssignment_3_2()); }
+(rule__TablePackage__TablesAssignment_3_2)*
+{ after(grammarAccess.getTablePackageAccess().getTablesAssignment_3_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePackage__Group_3__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePackage__Group_3__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePackage__Group_3__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePackageAccess().getRightCurlyBracketKeyword_3_3()); }
+
+	'}' 
+
+{ after(grammarAccess.getTablePackageAccess().getRightCurlyBracketKeyword_3_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__Table__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group__0__Impl
+	rule__Table__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getTableAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableAccess().getTableAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group__1__Impl
+	rule__Table__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getTableKeyword_1()); }
+
+	'table' 
+
+{ after(grammarAccess.getTableAccess().getTableKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group__2__Impl
+	rule__Table__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getNameAssignment_2()); }
+(rule__Table__NameAssignment_2)
+{ after(grammarAccess.getTableAccess().getNameAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group__3__Impl
+	rule__Table__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getGroup_3()); }
+(rule__Table__Group_3__0)?
+{ after(grammarAccess.getTableAccess().getGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group__4__Impl
+	rule__Table__Group__5
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getAsKeyword_4()); }
+
+	'as' 
+
+{ after(grammarAccess.getTableAccess().getAsKeyword_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group__5
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group__5__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group__5__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getTabletypeAssignment_5()); }
+(rule__Table__TabletypeAssignment_5)
+{ after(grammarAccess.getTableAccess().getTabletypeAssignment_5()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+rule__Table__Group_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group_3__0__Impl
+	rule__Table__Group_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getDescriptionAssignment_3_0()); }
+(rule__Table__DescriptionAssignment_3_0)
+{ after(grammarAccess.getTableAccess().getDescriptionAssignment_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__Table__Group_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__Table__Group_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__Table__Group_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAccess().getDescriptionValueAssignment_3_1()); }
+(rule__Table__DescriptionValueAssignment_3_1)
+{ after(grammarAccess.getTableAccess().getDescriptionValueAssignment_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group__0__Impl
+	rule__TableSelection__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getTableSelectionAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableSelectionAccess().getTableSelectionAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group__1__Impl
+	rule__TableSelection__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getAlternatives_1()); }
+(rule__TableSelection__Alternatives_1)
+{ after(grammarAccess.getTableSelectionAccess().getAlternatives_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group__2__Impl
+	rule__TableSelection__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2()); }
+(rule__TableSelection__UnorderedGroup_2)
+{ after(grammarAccess.getTableSelectionAccess().getUnorderedGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group__3__Impl
+	rule__TableSelection__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3()); }
+(rule__TableSelection__UnorderedGroup_3)
+{ after(grammarAccess.getTableSelectionAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getGroup_4()); }
+(rule__TableSelection__Group_4__0)?
+{ after(grammarAccess.getTableSelectionAccess().getGroup_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableSelection__Group_2_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_2_1__0__Impl
+	rule__TableSelection__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_2_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getRowheaderKeyword_2_1_0()); }
+
+	'rowheader' 
+
+{ after(grammarAccess.getTableSelectionAccess().getRowheaderKeyword_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_2_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_2_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getHeaderModeAssignment_2_1_1()); }
+(rule__TableSelection__HeaderModeAssignment_2_1_1)
+{ after(grammarAccess.getTableSelectionAccess().getHeaderModeAssignment_2_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group_3_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_3_0__0__Impl
+	rule__TableSelection__Group_3_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getPollingAssignment_3_0_0()); }
+(rule__TableSelection__PollingAssignment_3_0_0)
+{ after(grammarAccess.getTableSelectionAccess().getPollingAssignment_3_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_3_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_3_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getPollingTimeAssignment_3_0_1()); }
+(rule__TableSelection__PollingTimeAssignment_3_0_1)
+{ after(grammarAccess.getTableSelectionAccess().getPollingTimeAssignment_3_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group_3_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_3_3__0__Impl
+	rule__TableSelection__Group_3_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getToolbarKeyword_3_3_0()); }
+
+	'toolbar' 
+
+{ after(grammarAccess.getTableSelectionAccess().getToolbarKeyword_3_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_3_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_3_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_3_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getToolbarAssignment_3_3_1()); }
+(rule__TableSelection__ToolbarAssignment_3_3_1)
+{ after(grammarAccess.getTableSelectionAccess().getToolbarAssignment_3_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableSelection__Group_4__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_4__0__Impl
+	rule__TableSelection__Group_4__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_4__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getUsingKeyword_4_0()); }
+
+	'using' 
+
+{ after(grammarAccess.getTableSelectionAccess().getUsingKeyword_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableSelection__Group_4__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableSelection__Group_4__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableSelection__Group_4__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableSelectionAccess().getSourceAssignment_4_1()); }
+(rule__TableSelection__SourceAssignment_4_1)
+{ after(grammarAccess.getTableSelectionAccess().getSourceAssignment_4_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group__0__Impl
+	rule__TableTable__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getTableTableAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableTableAccess().getTableTableAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group__1__Impl
+	rule__TableTable__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getTableKeyword_1()); }
+
+	'table' 
+
+{ after(grammarAccess.getTableTableAccess().getTableKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group__2__Impl
+	rule__TableTable__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getUnorderedGroup_2()); }
+(rule__TableTable__UnorderedGroup_2)
+{ after(grammarAccess.getTableTableAccess().getUnorderedGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group__3__Impl
+	rule__TableTable__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getUnorderedGroup_3()); }
+(rule__TableTable__UnorderedGroup_3)
+{ after(grammarAccess.getTableTableAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getGroup_4()); }
+(rule__TableTable__Group_4__0)?
+{ after(grammarAccess.getTableTableAccess().getGroup_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableTable__Group_2_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_2_1__0__Impl
+	rule__TableTable__Group_2_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_2_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getRowheaderKeyword_2_1_0()); }
+
+	'rowheader' 
+
+{ after(grammarAccess.getTableTableAccess().getRowheaderKeyword_2_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_2_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_2_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_2_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getHeaderModeAssignment_2_1_1()); }
+(rule__TableTable__HeaderModeAssignment_2_1_1)
+{ after(grammarAccess.getTableTableAccess().getHeaderModeAssignment_2_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group_3_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_3_0__0__Impl
+	rule__TableTable__Group_3_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getPollingAssignment_3_0_0()); }
+(rule__TableTable__PollingAssignment_3_0_0)
+{ after(grammarAccess.getTableTableAccess().getPollingAssignment_3_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_3_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_3_0__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getPollingTimeAssignment_3_0_1()); }
+(rule__TableTable__PollingTimeAssignment_3_0_1)
+{ after(grammarAccess.getTableTableAccess().getPollingTimeAssignment_3_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group_3_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_3_3__0__Impl
+	rule__TableTable__Group_3_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getToolbarKeyword_3_3_0()); }
+
+	'toolbar' 
+
+{ after(grammarAccess.getTableTableAccess().getToolbarKeyword_3_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_3_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_3_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_3_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getToolbarAssignment_3_3_1()); }
+(rule__TableTable__ToolbarAssignment_3_3_1)
+{ after(grammarAccess.getTableTableAccess().getToolbarAssignment_3_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTable__Group_4__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_4__0__Impl
+	rule__TableTable__Group_4__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_4__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getUsingKeyword_4_0()); }
+
+	'using' 
+
+{ after(grammarAccess.getTableTableAccess().getUsingKeyword_4_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTable__Group_4__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTable__Group_4__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTable__Group_4__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTableAccess().getSourceAssignment_4_1()); }
+(rule__TableTable__SourceAssignment_4_1)
+{ after(grammarAccess.getTableTableAccess().getSourceAssignment_4_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TablePreorder__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePreorder__Group__0__Impl
+	rule__TablePreorder__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getTablePreorderAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTablePreorderAccess().getTablePreorderAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePreorder__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePreorder__Group__1__Impl
+	rule__TablePreorder__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getPreorderKeyword_1()); }
+
+	'preorder' 
+
+{ after(grammarAccess.getTablePreorderAccess().getPreorderKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePreorder__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePreorder__Group__2__Impl
+	rule__TablePreorder__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getColumnAssignment_2()); }
+(rule__TablePreorder__ColumnAssignment_2)
+{ after(grammarAccess.getTablePreorderAccess().getColumnAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TablePreorder__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TablePreorder__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TablePreorder__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePreorderAccess().getAscendingAssignment_3()); }
+(rule__TablePreorder__AscendingAssignment_3)?
+{ after(grammarAccess.getTablePreorderAccess().getAscendingAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableValue__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group__0__Impl
+	rule__TableValue__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getTableValueAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableValueAccess().getTableValueAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group__1__Impl
+	rule__TableValue__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getValueKeyword_1()); }
+
+	'value' 
+
+{ after(grammarAccess.getTableValueAccess().getValueKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group__2__Impl
+	rule__TableValue__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getColumnAssignment_2()); }
+(rule__TableValue__ColumnAssignment_2)
+{ after(grammarAccess.getTableValueAccess().getColumnAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group__3__Impl
+	rule__TableValue__Group__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getUnorderedGroup_3()); }
+(rule__TableValue__UnorderedGroup_3)
+{ after(grammarAccess.getTableValueAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getUnorderedGroup_4()); }
+(rule__TableValue__UnorderedGroup_4)
+{ after(grammarAccess.getTableValueAccess().getUnorderedGroup_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableValue__Group_3_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_3_1__0__Impl
+	rule__TableValue__Group_3_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIconKeyword_3_1_0()); }
+
+	'icon' 
+
+{ after(grammarAccess.getTableValueAccess().getIconKeyword_3_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_3_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_3_1__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIconNameAssignment_3_1_1()); }
+(rule__TableValue__IconNameAssignment_3_1_1)
+{ after(grammarAccess.getTableValueAccess().getIconNameAssignment_3_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableValue__Group_3_3__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_3_3__0__Impl
+	rule__TableValue__Group_3_3__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_3__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getHasImageAssignment_3_3_0()); }
+(rule__TableValue__HasImageAssignment_3_3_0)
+{ after(grammarAccess.getTableValueAccess().getHasImageAssignment_3_3_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_3_3__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_3_3__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_3_3__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getImageAssignment_3_3_1()); }
+(rule__TableValue__ImageAssignment_3_3_1)
+{ after(grammarAccess.getTableValueAccess().getImageAssignment_3_3_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableValue__Group_4_0__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_0__0__Impl
+	rule__TableValue__Group_4_0__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIntervalsKeyword_4_0_0()); }
+
+	'intervals' 
+
+{ after(grammarAccess.getTableValueAccess().getIntervalsKeyword_4_0_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_0__1__Impl
+	rule__TableValue__Group_4_0__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getHideLabelIntervalAssignment_4_0_1()); }
+(rule__TableValue__HideLabelIntervalAssignment_4_0_1)?
+{ after(grammarAccess.getTableValueAccess().getHideLabelIntervalAssignment_4_0_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_0__2__Impl
+	rule__TableValue__Group_4_0__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_0_2()); }
+
+	'{' 
+
+{ after(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_0_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_0__3__Impl
+	rule__TableValue__Group_4_0__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getIntervalsAssignment_4_0_3()); }
+(rule__TableValue__IntervalsAssignment_4_0_3)*
+{ after(grammarAccess.getTableValueAccess().getIntervalsAssignment_4_0_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_0__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_0__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_0__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_0_4()); }
+
+	'}' 
+
+{ after(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_0_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableValue__Group_4_1__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_1__0__Impl
+	rule__TableValue__Group_4_1__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLookupsKeyword_4_1_0()); }
+
+	'lookups' 
+
+{ after(grammarAccess.getTableValueAccess().getLookupsKeyword_4_1_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_1__1__Impl
+	rule__TableValue__Group_4_1__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getHideLabelLookupAssignment_4_1_1()); }
+(rule__TableValue__HideLabelLookupAssignment_4_1_1)?
+{ after(grammarAccess.getTableValueAccess().getHideLabelLookupAssignment_4_1_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_1__2__Impl
+	rule__TableValue__Group_4_1__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_1_2()); }
+
+	'{' 
+
+{ after(grammarAccess.getTableValueAccess().getLeftCurlyBracketKeyword_4_1_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_1__3__Impl
+	rule__TableValue__Group_4_1__4
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getLookupsAssignment_4_1_3()); }
+(rule__TableValue__LookupsAssignment_4_1_3)*
+{ after(grammarAccess.getTableValueAccess().getLookupsAssignment_4_1_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableValue__Group_4_1__4
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableValue__Group_4_1__4__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableValue__Group_4_1__4__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_1_4()); }
+
+	'}' 
+
+{ after(grammarAccess.getTableValueAccess().getRightCurlyBracketKeyword_4_1_4()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+
+
+rule__TableFormatter__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableFormatter__Group__0__Impl
+	rule__TableFormatter__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableFormatter__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableFormatterAccess().getTableFormatterAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableFormatterAccess().getTableFormatterAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableFormatter__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableFormatter__Group__1__Impl
+	rule__TableFormatter__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableFormatter__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableFormatterAccess().getFormatterKeyword_1()); }
+
+	'formatter' 
+
+{ after(grammarAccess.getTableFormatterAccess().getFormatterKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableFormatter__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableFormatter__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableFormatter__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableFormatterAccess().getFormatAssignment_2()); }
+(rule__TableFormatter__FormatAssignment_2)
+{ after(grammarAccess.getTableFormatterAccess().getFormatAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableImage__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableImage__Group__0__Impl
+	rule__TableImage__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getTableImageAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableImageAccess().getTableImageAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableImage__Group__1__Impl
+	rule__TableImage__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getPathKeyword_1()); }
+
+	'path' 
+
+{ after(grammarAccess.getTableImageAccess().getPathKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableImage__Group__2__Impl
+	rule__TableImage__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getImagePathPatternAssignment_2()); }
+(rule__TableImage__ImagePathPatternAssignment_2)
+{ after(grammarAccess.getTableImageAccess().getImagePathPatternAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableImage__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getUnorderedGroup_3()); }
+(rule__TableImage__UnorderedGroup_3)
+{ after(grammarAccess.getTableImageAccess().getUnorderedGroup_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableImage__Group_3_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableImage__Group_3_2__0__Impl
+	rule__TableImage__Group_3_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group_3_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getResizeAssignment_3_2_0()); }
+(rule__TableImage__ResizeAssignment_3_2_0)
+{ after(grammarAccess.getTableImageAccess().getResizeAssignment_3_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableImage__Group_3_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableImage__Group_3_2__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableImage__Group_3_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableImageAccess().getResizeStringAssignment_3_2_1()); }
+(rule__TableImage__ResizeStringAssignment_3_2_1)
+{ after(grammarAccess.getTableImageAccess().getResizeStringAssignment_3_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableTooltipPattern__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTooltipPattern__Group__0__Impl
+	rule__TableTooltipPattern__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTooltipPattern__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getTableTooltipPatternAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableTooltipPatternAccess().getTableTooltipPatternAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTooltipPattern__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTooltipPattern__Group__1__Impl
+	rule__TableTooltipPattern__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTooltipPattern__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternKeyword_1()); }
+
+	'tooltipPattern' 
+
+{ after(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTooltipPattern__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTooltipPattern__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTooltipPattern__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternAssignment_2()); }
+(rule__TableTooltipPattern__TooltipPatternAssignment_2)
+{ after(grammarAccess.getTableTooltipPatternAccess().getTooltipPatternAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableTask__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTask__Group__0__Impl
+	rule__TableTask__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTask__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTaskAccess().getTableTaskAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableTaskAccess().getTableTaskAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableTask__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableTask__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableTask__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableTaskAccess().getTaskIdKeyword_1()); }
+
+	'taskId' 
+
+{ after(grammarAccess.getTableTaskAccess().getTaskIdKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableAllColumns__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableAllColumns__Group__0__Impl
+	rule__TableAllColumns__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableAllColumns__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAllColumnsAccess().getTableAllColumnsAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableAllColumnsAccess().getTableAllColumnsAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableAllColumns__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableAllColumns__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableAllColumns__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAllColumnsAccess().getAllColumnsKeyword_1()); }
+
+	'allColumns' 
+
+{ after(grammarAccess.getTableAllColumnsAccess().getAllColumnsKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableOrdinal__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableOrdinal__Group__0__Impl
+	rule__TableOrdinal__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableOrdinal__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableOrdinalAccess().getOrdinalKeyword_0()); }
+
+	'ordinal' 
+
+{ after(grammarAccess.getTableOrdinalAccess().getOrdinalKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableOrdinal__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableOrdinal__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableOrdinal__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableOrdinalAccess().getValueRefAssignment_1()); }
+(rule__TableOrdinal__ValueRefAssignment_1)
+{ after(grammarAccess.getTableOrdinalAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableColumn__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableColumn__Group__0__Impl
+	rule__TableColumn__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableColumn__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableColumnAccess().getColumnKeyword_0()); }
+
+	'column' 
+
+{ after(grammarAccess.getTableColumnAccess().getColumnKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableColumn__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableColumn__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableColumn__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableColumnAccess().getValueRefAssignment_1()); }
+(rule__TableColumn__ValueRefAssignment_1)
+{ after(grammarAccess.getTableColumnAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableMeasure__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableMeasure__Group__0__Impl
+	rule__TableMeasure__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableMeasure__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableMeasureAccess().getMeasureKeyword_0()); }
+
+	'measure' 
+
+{ after(grammarAccess.getTableMeasureAccess().getMeasureKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableMeasure__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableMeasure__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableMeasure__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableMeasureAccess().getValueRefAssignment_1()); }
+(rule__TableMeasure__ValueRefAssignment_1)
+{ after(grammarAccess.getTableMeasureAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableDerived__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDerived__Group__0__Impl
+	rule__TableDerived__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDerived__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDerivedAccess().getDerivedKeyword_0()); }
+
+	'derived' 
+
+{ after(grammarAccess.getTableDerivedAccess().getDerivedKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDerived__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDerived__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDerived__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDerivedAccess().getValueRefAssignment_1()); }
+(rule__TableDerived__ValueRefAssignment_1)
+{ after(grammarAccess.getTableDerivedAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableHierarchy__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableHierarchy__Group__0__Impl
+	rule__TableHierarchy__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableHierarchy__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableHierarchyAccess().getLevelKeyword_0()); }
+
+	'level' 
+
+{ after(grammarAccess.getTableHierarchyAccess().getLevelKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableHierarchy__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableHierarchy__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableHierarchy__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableHierarchyAccess().getValueRefAssignment_1()); }
+(rule__TableHierarchy__ValueRefAssignment_1)
+{ after(grammarAccess.getTableHierarchyAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableProperty__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableProperty__Group__0__Impl
+	rule__TableProperty__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableProperty__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePropertyAccess().getTablePropertyAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTablePropertyAccess().getTablePropertyAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableProperty__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableProperty__Group__1__Impl
+	rule__TableProperty__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableProperty__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePropertyAccess().getPropertyKeyword_1()); }
+
+	'property' 
+
+{ after(grammarAccess.getTablePropertyAccess().getPropertyKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableProperty__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableProperty__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableProperty__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTablePropertyAccess().getValueRefAssignment_2()); }
+(rule__TableProperty__ValueRefAssignment_2)
+{ after(grammarAccess.getTablePropertyAccess().getValueRefAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableAggregation__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableAggregation__Group__0__Impl
+	rule__TableAggregation__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableAggregation__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAggregationAccess().getAggregationKeyword_0()); }
+
+	'aggregation' 
+
+{ after(grammarAccess.getTableAggregationAccess().getAggregationKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableAggregation__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableAggregation__Group__1__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableAggregation__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableAggregationAccess().getValueRefAssignment_1()); }
+(rule__TableAggregation__ValueRefAssignment_1)
+{ after(grammarAccess.getTableAggregationAccess().getValueRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+rule__TableNumberInterval__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberInterval__Group__0__Impl
+	rule__TableNumberInterval__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getTableNumberIntervalAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableNumberIntervalAccess().getTableNumberIntervalAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberInterval__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberInterval__Group__1__Impl
+	rule__TableNumberInterval__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getUpToKeyword_1()); }
+
+	'up to' 
+
+{ after(grammarAccess.getTableNumberIntervalAccess().getUpToKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberInterval__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberInterval__Group__2__Impl
+	rule__TableNumberInterval__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getNumberIntervalValueAssignment_2()); }
+(rule__TableNumberInterval__NumberIntervalValueAssignment_2)
+{ after(grammarAccess.getTableNumberIntervalAccess().getNumberIntervalValueAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberInterval__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberInterval__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberInterval__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberIntervalAccess().getNumberRangeAssignment_3()); }
+(rule__TableNumberInterval__NumberRangeAssignment_3)
+{ after(grammarAccess.getTableNumberIntervalAccess().getNumberRangeAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableDateDayInterval__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayInterval__Group__0__Impl
+	rule__TableDateDayInterval__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getTableDateDayIntervalAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getTableDateDayIntervalAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayInterval__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayInterval__Group__1__Impl
+	rule__TableDateDayInterval__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getDaysInPastKeyword_1()); }
+
+	'days in past' 
+
+{ after(grammarAccess.getTableDateDayIntervalAccess().getDaysInPastKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayInterval__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayInterval__Group__2__Impl
+	rule__TableDateDayInterval__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getDateIntervalValueAssignment_2()); }
+(rule__TableDateDayInterval__DateIntervalValueAssignment_2)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getDateIntervalValueAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayInterval__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayInterval__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayInterval__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayIntervalAccess().getDateRangeAssignment_3()); }
+(rule__TableDateDayInterval__DateRangeAssignment_3)
+{ after(grammarAccess.getTableDateDayIntervalAccess().getDateRangeAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableNumberLookup__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberLookup__Group__0__Impl
+	rule__TableNumberLookup__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getTableNumberLookupAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableNumberLookupAccess().getTableNumberLookupAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberLookup__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberLookup__Group__1__Impl
+	rule__TableNumberLookup__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getNumberKeyword_1()); }
+
+	'number' 
+
+{ after(grammarAccess.getTableNumberLookupAccess().getNumberKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberLookup__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberLookup__Group__2__Impl
+	rule__TableNumberLookup__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getLookupValueAssignment_2()); }
+(rule__TableNumberLookup__LookupValueAssignment_2)
+{ after(grammarAccess.getTableNumberLookupAccess().getLookupValueAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableNumberLookup__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableNumberLookup__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableNumberLookup__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableNumberLookupAccess().getDiscreteAssignment_3()); }
+(rule__TableNumberLookup__DiscreteAssignment_3)
+{ after(grammarAccess.getTableNumberLookupAccess().getDiscreteAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableStringLookup__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableStringLookup__Group__0__Impl
+	rule__TableStringLookup__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getTableStringLookupAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableStringLookupAccess().getTableStringLookupAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableStringLookup__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableStringLookup__Group__1__Impl
+	rule__TableStringLookup__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getStringKeyword_1()); }
+
+	'string' 
+
+{ after(grammarAccess.getTableStringLookupAccess().getStringKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableStringLookup__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableStringLookup__Group__2__Impl
+	rule__TableStringLookup__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getLookupValueAssignment_2()); }
+(rule__TableStringLookup__LookupValueAssignment_2)
+{ after(grammarAccess.getTableStringLookupAccess().getLookupValueAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableStringLookup__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableStringLookup__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableStringLookup__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableStringLookupAccess().getDiscreteAssignment_3()); }
+(rule__TableStringLookup__DiscreteAssignment_3)
+{ after(grammarAccess.getTableStringLookupAccess().getDiscreteAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableDateDayLookup__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayLookup__Group__0__Impl
+	rule__TableDateDayLookup__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getTableDateDayLookupAction_0()); }
+(
+
+)
+{ after(grammarAccess.getTableDateDayLookupAccess().getTableDateDayLookupAction_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayLookup__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayLookup__Group__1__Impl
+	rule__TableDateDayLookup__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getDaysInPastKeyword_1()); }
+
+	'days in past' 
+
+{ after(grammarAccess.getTableDateDayLookupAccess().getDaysInPastKeyword_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayLookup__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayLookup__Group__2__Impl
+	rule__TableDateDayLookup__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getLookupValueAssignment_2()); }
+(rule__TableDateDayLookup__LookupValueAssignment_2)
+{ after(grammarAccess.getTableDateDayLookupAccess().getLookupValueAssignment_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDateDayLookup__Group__3
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDateDayLookup__Group__3__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDateDayLookup__Group__3__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDateDayLookupAccess().getDiscreteAssignment_3()); }
+(rule__TableDateDayLookup__DiscreteAssignment_3)
+{ after(grammarAccess.getTableDateDayLookupAccess().getDiscreteAssignment_3()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+
+
+rule__TableDatamart__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDatamart__Group__0__Impl
+	rule__TableDatamart__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getDatamartKeyword_0()); }
+
+	'datamart' 
+
+{ after(grammarAccess.getTableDatamartAccess().getDatamartKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDatamart__Group__1__Impl
+	rule__TableDatamart__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getDatamartRefAssignment_1()); }
+(rule__TableDatamart__DatamartRefAssignment_1)
+{ after(grammarAccess.getTableDatamartAccess().getDatamartRefAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDatamart__Group__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getGroup_2()); }
+(rule__TableDatamart__Group_2__0)?
+{ after(grammarAccess.getTableDatamartAccess().getGroup_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableDatamart__Group_2__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDatamart__Group_2__0__Impl
+	rule__TableDatamart__Group_2__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group_2__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getLeftCurlyBracketKeyword_2_0()); }
+
+	'{' 
+
+{ after(grammarAccess.getTableDatamartAccess().getLeftCurlyBracketKeyword_2_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group_2__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDatamart__Group_2__1__Impl
+	rule__TableDatamart__Group_2__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group_2__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getElementsAssignment_2_1()); }
+(rule__TableDatamart__ElementsAssignment_2_1)*
+{ after(grammarAccess.getTableDatamartAccess().getElementsAssignment_2_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableDatamart__Group_2__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableDatamart__Group_2__2__Impl
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableDatamart__Group_2__2__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableDatamartAccess().getRightCurlyBracketKeyword_2_2()); }
+
+	'}' 
+
+{ after(grammarAccess.getTableDatamartAccess().getRightCurlyBracketKeyword_2_2()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+
+
+
+
+
+
+rule__TableEvent__Group__0
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableEvent__Group__0__Impl
+	rule__TableEvent__Group__1
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableEvent__Group__0__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableEventAccess().getBrokerKeyword_0()); }
+
+	'broker' 
+
+{ after(grammarAccess.getTableEventAccess().getBrokerKeyword_0()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableEvent__Group__1
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableEvent__Group__1__Impl
+	rule__TableEvent__Group__2
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableEvent__Group__1__Impl
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+(
+{ before(grammarAccess.getTableEventAccess().getSourceAssignment_1()); }
+(rule__TableEvent__SourceAssignment_1)
+{ after(grammarAccess.getTableEventAccess().getSourceAssignment_1()); }
+)
+
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+
+rule__TableEvent__Group__2
+    @init {
+		int stackSize = keepStackSize();
+    }
+:
+	rule__TableEvent__Group__2__Impl
+	rule__TableEvent__Group__3
+;
+finally {
+	restoreStackSize(stackSize);
+}
+
+rule__TableEvent__Group__2__Impl
+    @init {
+		int stackSize = keepStackSize();