org.eclipse.osbp.xtext.table.ui/src-gen/org/eclipse/osbp/xtext/table/ui/contentassist/antlr/internal/InternalTableDSL.g

/**
 *                                                                            
 *  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();