org.eclipse.osbp.ecview.dsl.ui/src-gen/org/eclipse/osbp/ecview/dsl/ui/contentassist/antlr/internal/InternalUIGrammar.g

/**
 * Copyright (c) 2011, 2015 - Lunifera GmbH (Gross Enzersdorf), Loetz GmbH&Co.KG (Heidelberg)
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *         Florian Pirchner - Initial implementation
 */

grammar InternalUIGrammar;

options {
	superClass=AbstractInternalContentAssistParser;
	backtrack=true;
	
}

@lexer::header {
package org.eclipse.osbp.ecview.dsl.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.ecview.dsl.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.ecview.dsl.services.UIGrammarGrammarAccess;

}

@parser::members {
 
 	private UIGrammarGrammarAccess grammarAccess;
 	
    public void setGrammarAccess(UIGrammarGrammarAccess grammarAccess) {
    	this.grammarAccess = grammarAccess;
    }
    
    @Override
    protected Grammar getGrammar() {
    	return grammarAccess.getGrammar();
    }
    
    @Override
    protected String getValueForTokenName(String tokenName) {
    	return tokenName;
    }

}




// Entry rule entryRuleUiModel
entryRuleUiModel 
:
{ before(grammarAccess.getUiModelRule()); }
	 ruleUiModel
{ after(grammarAccess.getUiModelRule()); } 
	 EOF 
;

// Rule UiModel
ruleUiModel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiModelAccess().getGroup()); }
(rule__UiModel__Group__0)
{ after(grammarAccess.getUiModelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiImports
entryRuleUiImports 
:
{ before(grammarAccess.getUiImportsRule()); }
	 ruleUiImports
{ after(grammarAccess.getUiImportsRule()); } 
	 EOF 
;

// Rule UiImports
ruleUiImports
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiImportsAccess().getGroup()); }
(rule__UiImports__Group__0)
{ after(grammarAccess.getUiImportsAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiRootElements
entryRuleUiRootElements 
:
{ before(grammarAccess.getUiRootElementsRule()); }
	 ruleUiRootElements
{ after(grammarAccess.getUiRootElementsRule()); } 
	 EOF 
;

// Rule UiRootElements
ruleUiRootElements
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiRootElementsAccess().getAlternatives()); }
(rule__UiRootElements__Alternatives)
{ after(grammarAccess.getUiRootElementsAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiValidatorAlias
entryRuleUiValidatorAlias 
:
{ before(grammarAccess.getUiValidatorAliasRule()); }
	 ruleUiValidatorAlias
{ after(grammarAccess.getUiValidatorAliasRule()); } 
	 EOF 
;

// Rule UiValidatorAlias
ruleUiValidatorAlias
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiValidatorAliasAccess().getGroup()); }
(rule__UiValidatorAlias__Group__0)
{ after(grammarAccess.getUiValidatorAliasAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiValidatorAssignment
entryRuleUiValidatorAssignment 
:
{ before(grammarAccess.getUiValidatorAssignmentRule()); }
	 ruleUiValidatorAssignment
{ after(grammarAccess.getUiValidatorAssignmentRule()); } 
	 EOF 
;

// Rule UiValidatorAssignment
ruleUiValidatorAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getGroup()); }
(rule__UiValidatorAssignment__Group__0)
{ after(grammarAccess.getUiValidatorAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiValidatorDef
entryRuleUiValidatorDef 
:
{ before(grammarAccess.getUiValidatorDefRule()); }
	 ruleUiValidatorDef
{ after(grammarAccess.getUiValidatorDefRule()); } 
	 EOF 
;

// Rule UiValidatorDef
ruleUiValidatorDef
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiValidatorDefAccess().getValidatorAssignment()); }
(rule__UiValidatorDef__ValidatorAssignment)
{ after(grammarAccess.getUiValidatorDefAccess().getValidatorAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiViewSet
entryRuleUiViewSet 
:
{ before(grammarAccess.getUiViewSetRule()); }
	 ruleUiViewSet
{ after(grammarAccess.getUiViewSetRule()); } 
	 EOF 
;

// Rule UiViewSet
ruleUiViewSet
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiViewSetAccess().getGroup()); }
(rule__UiViewSet__Group__0)
{ after(grammarAccess.getUiViewSetAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBindingEndpointAlias
entryRuleUiBindingEndpointAlias 
:
{ before(grammarAccess.getUiBindingEndpointAliasRule()); }
	 ruleUiBindingEndpointAlias
{ after(grammarAccess.getUiBindingEndpointAliasRule()); } 
	 EOF 
;

// Rule UiBindingEndpointAlias
ruleUiBindingEndpointAlias
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBindingEndpointAliasAccess().getGroup()); }
(rule__UiBindingEndpointAlias__Group__0)
{ after(grammarAccess.getUiBindingEndpointAliasAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBeanSlot
entryRuleUiBeanSlot 
:
{ before(grammarAccess.getUiBeanSlotRule()); }
	 ruleUiBeanSlot
{ after(grammarAccess.getUiBeanSlotRule()); } 
	 EOF 
;

// Rule UiBeanSlot
ruleUiBeanSlot
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBeanSlotAccess().getGroup()); }
(rule__UiBeanSlot__Group__0)
{ after(grammarAccess.getUiBeanSlotAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBinding
entryRuleUiBinding 
:
{ before(grammarAccess.getUiBindingRule()); }
	 ruleUiBinding
{ after(grammarAccess.getUiBindingRule()); } 
	 EOF 
;

// Rule UiBinding
ruleUiBinding
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBindingAccess().getGroup()); }
(rule__UiBinding__Group__0)
{ after(grammarAccess.getUiBindingAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBindingEndpointAssignment
entryRuleUiBindingEndpointAssignment 
:
{ before(grammarAccess.getUiBindingEndpointAssignmentRule()); }
	 ruleUiBindingEndpointAssignment
{ after(grammarAccess.getUiBindingEndpointAssignmentRule()); } 
	 EOF 
;

// Rule UiBindingEndpointAssignment
ruleUiBindingEndpointAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getAlternatives()); }
(rule__UiBindingEndpointAssignment__Alternatives)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiPathSegment
entryRuleUiPathSegment 
:
{ before(grammarAccess.getUiPathSegmentRule()); }
	 ruleUiPathSegment
{ after(grammarAccess.getUiPathSegmentRule()); } 
	 EOF 
;

// Rule UiPathSegment
ruleUiPathSegment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiPathSegmentAccess().getGroup()); }
(rule__UiPathSegment__Group__0)
{ after(grammarAccess.getUiPathSegmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiNestedProperty
entryRuleUiNestedProperty 
:
{ before(grammarAccess.getUiNestedPropertyRule()); }
	 ruleUiNestedProperty
{ after(grammarAccess.getUiNestedPropertyRule()); } 
	 EOF 
;

// Rule UiNestedProperty
ruleUiNestedProperty
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiNestedPropertyAccess().getGroup()); }
(rule__UiNestedProperty__Group__0)
{ after(grammarAccess.getUiNestedPropertyAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTypedBindableDef
entryRuleUiTypedBindableDef 
:
{ before(grammarAccess.getUiTypedBindableDefRule()); }
	 ruleUiTypedBindableDef
{ after(grammarAccess.getUiTypedBindableDefRule()); } 
	 EOF 
;

// Rule UiTypedBindableDef
ruleUiTypedBindableDef
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTypedBindableDefAccess().getGroup()); }
(rule__UiTypedBindableDef__Group__0)
{ after(grammarAccess.getUiTypedBindableDefAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTypedBindableRawType
entryRuleUiTypedBindableRawType 
:
{ before(grammarAccess.getUiTypedBindableRawTypeRule()); }
	 ruleUiTypedBindableRawType
{ after(grammarAccess.getUiTypedBindableRawTypeRule()); } 
	 EOF 
;

// Rule UiTypedBindableRawType
ruleUiTypedBindableRawType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTypedBindableRawTypeAccess().getGroup()); }
(rule__UiTypedBindableRawType__Group__0)
{ after(grammarAccess.getUiTypedBindableRawTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTypedBindableRawTypeAlias
entryRuleUiTypedBindableRawTypeAlias 
:
{ before(grammarAccess.getUiTypedBindableRawTypeAliasRule()); }
	 ruleUiTypedBindableRawTypeAlias
{ after(grammarAccess.getUiTypedBindableRawTypeAliasRule()); } 
	 EOF 
;

// Rule UiTypedBindableRawTypeAlias
ruleUiTypedBindableRawTypeAlias
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTypedBindableRawTypeAliasAccess().getGroup()); }
(rule__UiTypedBindableRawTypeAlias__Group__0)
{ after(grammarAccess.getUiTypedBindableRawTypeAliasAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiRawBindablePathSegment
entryRuleUiRawBindablePathSegment 
:
{ before(grammarAccess.getUiRawBindablePathSegmentRule()); }
	 ruleUiRawBindablePathSegment
{ after(grammarAccess.getUiRawBindablePathSegmentRule()); } 
	 EOF 
;

// Rule UiRawBindablePathSegment
ruleUiRawBindablePathSegment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiRawBindablePathSegmentAccess().getGroup()); }
(rule__UiRawBindablePathSegment__Group__0)
{ after(grammarAccess.getUiRawBindablePathSegmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiCommandBindableDef
entryRuleUiCommandBindableDef 
:
{ before(grammarAccess.getUiCommandBindableDefRule()); }
	 ruleUiCommandBindableDef
{ after(grammarAccess.getUiCommandBindableDefRule()); } 
	 EOF 
;

// Rule UiCommandBindableDef
ruleUiCommandBindableDef
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiCommandBindableDefAccess().getGroup()); }
(rule__UiCommandBindableDef__Group__0)
{ after(grammarAccess.getUiCommandBindableDefAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiCommand
entryRuleUiCommand 
:
{ before(grammarAccess.getUiCommandRule()); }
	 ruleUiCommand
{ after(grammarAccess.getUiCommandRule()); } 
	 EOF 
;

// Rule UiCommand
ruleUiCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiCommandAccess().getAlternatives()); }
(rule__UiCommand__Alternatives)
{ after(grammarAccess.getUiCommandAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavigationCommand
entryRuleUiMobileNavigationCommand 
:
{ before(grammarAccess.getUiMobileNavigationCommandRule()); }
	 ruleUiMobileNavigationCommand
{ after(grammarAccess.getUiMobileNavigationCommandRule()); } 
	 EOF 
;

// Rule UiMobileNavigationCommand
ruleUiMobileNavigationCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavigationCommandAccess().getGroup()); }
(rule__UiMobileNavigationCommand__Group__0)
{ after(grammarAccess.getUiMobileNavigationCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiOpenDialogCommand
entryRuleUiOpenDialogCommand 
:
{ before(grammarAccess.getUiOpenDialogCommandRule()); }
	 ruleUiOpenDialogCommand
{ after(grammarAccess.getUiOpenDialogCommandRule()); } 
	 EOF 
;

// Rule UiOpenDialogCommand
ruleUiOpenDialogCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiOpenDialogCommandAccess().getGroup()); }
(rule__UiOpenDialogCommand__Group__0)
{ after(grammarAccess.getUiOpenDialogCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSearchWithDialogCommand
entryRuleUiSearchWithDialogCommand 
:
{ before(grammarAccess.getUiSearchWithDialogCommandRule()); }
	 ruleUiSearchWithDialogCommand
{ after(grammarAccess.getUiSearchWithDialogCommandRule()); } 
	 EOF 
;

// Rule UiSearchWithDialogCommand
ruleUiSearchWithDialogCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSearchWithDialogCommandAccess().getGroup()); }
(rule__UiSearchWithDialogCommand__Group__0)
{ after(grammarAccess.getUiSearchWithDialogCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiAddToTableCommand
entryRuleUiAddToTableCommand 
:
{ before(grammarAccess.getUiAddToTableCommandRule()); }
	 ruleUiAddToTableCommand
{ after(grammarAccess.getUiAddToTableCommandRule()); } 
	 EOF 
;

// Rule UiAddToTableCommand
ruleUiAddToTableCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiAddToTableCommandAccess().getGroup()); }
(rule__UiAddToTableCommand__Group__0)
{ after(grammarAccess.getUiAddToTableCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiRemoveFromTableCommand
entryRuleUiRemoveFromTableCommand 
:
{ before(grammarAccess.getUiRemoveFromTableCommandRule()); }
	 ruleUiRemoveFromTableCommand
{ after(grammarAccess.getUiRemoveFromTableCommandRule()); } 
	 EOF 
;

// Rule UiRemoveFromTableCommand
ruleUiRemoveFromTableCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiRemoveFromTableCommandAccess().getGroup()); }
(rule__UiRemoveFromTableCommand__Group__0)
{ after(grammarAccess.getUiRemoveFromTableCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSetNewInstanceCommand
entryRuleUiSetNewInstanceCommand 
:
{ before(grammarAccess.getUiSetNewInstanceCommandRule()); }
	 ruleUiSetNewInstanceCommand
{ after(grammarAccess.getUiSetNewInstanceCommandRule()); } 
	 EOF 
;

// Rule UiSetNewInstanceCommand
ruleUiSetNewInstanceCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSetNewInstanceCommandAccess().getGroup()); }
(rule__UiSetNewInstanceCommand__Group__0)
{ after(grammarAccess.getUiSetNewInstanceCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSendEventCommand
entryRuleUiSendEventCommand 
:
{ before(grammarAccess.getUiSendEventCommandRule()); }
	 ruleUiSendEventCommand
{ after(grammarAccess.getUiSendEventCommandRule()); } 
	 EOF 
;

// Rule UiSendEventCommand
ruleUiSendEventCommand
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSendEventCommandAccess().getGroup()); }
(rule__UiSendEventCommand__Group__0)
{ after(grammarAccess.getUiSendEventCommandAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiView
entryRuleUiView 
:
{ before(grammarAccess.getUiViewRule()); }
	 ruleUiView
{ after(grammarAccess.getUiViewRule()); } 
	 EOF 
;

// Rule UiView
ruleUiView
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiViewAccess().getUiIDEViewParserRuleCall()); }
	ruleUiIDEView
{ after(grammarAccess.getUiViewAccess().getUiIDEViewParserRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiIDEView
entryRuleUiIDEView 
:
{ before(grammarAccess.getUiIDEViewRule()); }
	 ruleUiIDEView
{ after(grammarAccess.getUiIDEViewRule()); } 
	 EOF 
;

// Rule UiIDEView
ruleUiIDEView
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiIDEViewAccess().getGroup()); }
(rule__UiIDEView__Group__0)
{ after(grammarAccess.getUiIDEViewAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiExposedAction
entryRuleUiExposedAction 
:
{ before(grammarAccess.getUiExposedActionRule()); }
	 ruleUiExposedAction
{ after(grammarAccess.getUiExposedActionRule()); } 
	 EOF 
;

// Rule UiExposedAction
ruleUiExposedAction
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiExposedActionAccess().getGroup()); }
(rule__UiExposedAction__Group__0)
{ after(grammarAccess.getUiExposedActionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavBarAction
entryRuleUiMobileNavBarAction 
:
{ before(grammarAccess.getUiMobileNavBarActionRule()); }
	 ruleUiMobileNavBarAction
{ after(grammarAccess.getUiMobileNavBarActionRule()); } 
	 EOF 
;

// Rule UiMobileNavBarAction
ruleUiMobileNavBarAction
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavBarActionAccess().getGroup()); }
(rule__UiMobileNavBarAction__Group__0)
{ after(grammarAccess.getUiMobileNavBarActionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileView
entryRuleUiMobileView 
:
{ before(grammarAccess.getUiMobileViewRule()); }
	 ruleUiMobileView
{ after(grammarAccess.getUiMobileViewRule()); } 
	 EOF 
;

// Rule UiMobileView
ruleUiMobileView
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileViewAccess().getGroup()); }
(rule__UiMobileView__Group__0)
{ after(grammarAccess.getUiMobileViewAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiI18nInfo
entryRuleUiI18nInfo 
:
{ before(grammarAccess.getUiI18nInfoRule()); }
	 ruleUiI18nInfo
{ after(grammarAccess.getUiI18nInfoRule()); } 
	 EOF 
;

// Rule UiI18nInfo
ruleUiI18nInfo
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiI18nInfoAccess().getGroup()); }
(rule__UiI18nInfo__Group__0)
{ after(grammarAccess.getUiI18nInfoAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiGridLayout
entryRuleUiGridLayout 
:
{ before(grammarAccess.getUiGridLayoutRule()); }
	 ruleUiGridLayout
{ after(grammarAccess.getUiGridLayoutRule()); } 
	 EOF 
;

// Rule UiGridLayout
ruleUiGridLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiGridLayoutAccess().getGroup()); }
(rule__UiGridLayout__Group__0)
{ after(grammarAccess.getUiGridLayoutAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiVisibilityProcessorAssignment
entryRuleUiVisibilityProcessorAssignment 
:
{ before(grammarAccess.getUiVisibilityProcessorAssignmentRule()); }
	 ruleUiVisibilityProcessorAssignment
{ after(grammarAccess.getUiVisibilityProcessorAssignmentRule()); } 
	 EOF 
;

// Rule UiVisibilityProcessorAssignment
ruleUiVisibilityProcessorAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiVisibilityProcessorAssignmentAccess().getGroup()); }
(rule__UiVisibilityProcessorAssignment__Group__0)
{ after(grammarAccess.getUiVisibilityProcessorAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiGridLayoutAssigment
entryRuleUiGridLayoutAssigment 
:
{ before(grammarAccess.getUiGridLayoutAssigmentRule()); }
	 ruleUiGridLayoutAssigment
{ after(grammarAccess.getUiGridLayoutAssigmentRule()); } 
	 EOF 
;

// Rule UiGridLayoutAssigment
ruleUiGridLayoutAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiGridLayoutAssigmentAccess().getGroup()); }
(rule__UiGridLayoutAssigment__Group__0)
{ after(grammarAccess.getUiGridLayoutAssigmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiFormLayout
entryRuleUiFormLayout 
:
{ before(grammarAccess.getUiFormLayoutRule()); }
	 ruleUiFormLayout
{ after(grammarAccess.getUiFormLayoutRule()); } 
	 EOF 
;

// Rule UiFormLayout
ruleUiFormLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiFormLayoutAccess().getGroup()); }
(rule__UiFormLayout__Group__0)
{ after(grammarAccess.getUiFormLayoutAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiFormLayoutAssigment
entryRuleUiFormLayoutAssigment 
:
{ before(grammarAccess.getUiFormLayoutAssigmentRule()); }
	 ruleUiFormLayoutAssigment
{ after(grammarAccess.getUiFormLayoutAssigmentRule()); } 
	 EOF 
;

// Rule UiFormLayoutAssigment
ruleUiFormLayoutAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiFormLayoutAssigmentAccess().getElementAssignment()); }
(rule__UiFormLayoutAssigment__ElementAssignment)
{ after(grammarAccess.getUiFormLayoutAssigmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiVerticalLayout
entryRuleUiVerticalLayout 
:
{ before(grammarAccess.getUiVerticalLayoutRule()); }
	 ruleUiVerticalLayout
{ after(grammarAccess.getUiVerticalLayoutRule()); } 
	 EOF 
;

// Rule UiVerticalLayout
ruleUiVerticalLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiVerticalLayoutAccess().getGroup()); }
(rule__UiVerticalLayout__Group__0)
{ after(grammarAccess.getUiVerticalLayoutAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiVerticalLayoutAssigment
entryRuleUiVerticalLayoutAssigment 
:
{ before(grammarAccess.getUiVerticalLayoutAssigmentRule()); }
	 ruleUiVerticalLayoutAssigment
{ after(grammarAccess.getUiVerticalLayoutAssigmentRule()); } 
	 EOF 
;

// Rule UiVerticalLayoutAssigment
ruleUiVerticalLayoutAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiVerticalLayoutAssigmentAccess().getGroup()); }
(rule__UiVerticalLayoutAssigment__Group__0)
{ after(grammarAccess.getUiVerticalLayoutAssigmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileVerticalLayout
entryRuleUiMobileVerticalLayout 
:
{ before(grammarAccess.getUiMobileVerticalLayoutRule()); }
	 ruleUiMobileVerticalLayout
{ after(grammarAccess.getUiMobileVerticalLayoutRule()); } 
	 EOF 
;

// Rule UiMobileVerticalLayout
ruleUiMobileVerticalLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileVerticalLayoutAccess().getGroup()); }
(rule__UiMobileVerticalLayout__Group__0)
{ after(grammarAccess.getUiMobileVerticalLayoutAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileVerticalLayoutAssigment
entryRuleUiMobileVerticalLayoutAssigment 
:
{ before(grammarAccess.getUiMobileVerticalLayoutAssigmentRule()); }
	 ruleUiMobileVerticalLayoutAssigment
{ after(grammarAccess.getUiMobileVerticalLayoutAssigmentRule()); } 
	 EOF 
;

// Rule UiMobileVerticalLayoutAssigment
ruleUiMobileVerticalLayoutAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileVerticalLayoutAssigmentAccess().getGroup()); }
(rule__UiMobileVerticalLayoutAssigment__Group__0)
{ after(grammarAccess.getUiMobileVerticalLayoutAssigmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavigationRoot
entryRuleUiMobileNavigationRoot 
:
{ before(grammarAccess.getUiMobileNavigationRootRule()); }
	 ruleUiMobileNavigationRoot
{ after(grammarAccess.getUiMobileNavigationRootRule()); } 
	 EOF 
;

// Rule UiMobileNavigationRoot
ruleUiMobileNavigationRoot
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavigationRootAccess().getGroup()); }
(rule__UiMobileNavigationRoot__Group__0)
{ after(grammarAccess.getUiMobileNavigationRootAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavigationRootAssigment
entryRuleUiMobileNavigationRootAssigment 
:
{ before(grammarAccess.getUiMobileNavigationRootAssigmentRule()); }
	 ruleUiMobileNavigationRootAssigment
{ after(grammarAccess.getUiMobileNavigationRootAssigmentRule()); } 
	 EOF 
;

// Rule UiMobileNavigationRootAssigment
ruleUiMobileNavigationRootAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavigationRootAssigmentAccess().getElementAssignment()); }
(rule__UiMobileNavigationRootAssigment__ElementAssignment)
{ after(grammarAccess.getUiMobileNavigationRootAssigmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiHorizontalLayout
entryRuleUiHorizontalLayout 
:
{ before(grammarAccess.getUiHorizontalLayoutRule()); }
	 ruleUiHorizontalLayout
{ after(grammarAccess.getUiHorizontalLayoutRule()); } 
	 EOF 
;

// Rule UiHorizontalLayout
ruleUiHorizontalLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiHorizontalLayoutAccess().getGroup()); }
(rule__UiHorizontalLayout__Group__0)
{ after(grammarAccess.getUiHorizontalLayoutAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiHorizontalLayoutAssigment
entryRuleUiHorizontalLayoutAssigment 
:
{ before(grammarAccess.getUiHorizontalLayoutAssigmentRule()); }
	 ruleUiHorizontalLayoutAssigment
{ after(grammarAccess.getUiHorizontalLayoutAssigmentRule()); } 
	 EOF 
;

// Rule UiHorizontalLayoutAssigment
ruleUiHorizontalLayoutAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiHorizontalLayoutAssigmentAccess().getGroup()); }
(rule__UiHorizontalLayoutAssigment__Group__0)
{ after(grammarAccess.getUiHorizontalLayoutAssigmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileHorizontalLayout
entryRuleUiMobileHorizontalLayout 
:
{ before(grammarAccess.getUiMobileHorizontalLayoutRule()); }
	 ruleUiMobileHorizontalLayout
{ after(grammarAccess.getUiMobileHorizontalLayoutRule()); } 
	 EOF 
;

// Rule UiMobileHorizontalLayout
ruleUiMobileHorizontalLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileHorizontalLayoutAccess().getGroup()); }
(rule__UiMobileHorizontalLayout__Group__0)
{ after(grammarAccess.getUiMobileHorizontalLayoutAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileHorizontalLayoutAssigment
entryRuleUiMobileHorizontalLayoutAssigment 
:
{ before(grammarAccess.getUiMobileHorizontalLayoutAssigmentRule()); }
	 ruleUiMobileHorizontalLayoutAssigment
{ after(grammarAccess.getUiMobileHorizontalLayoutAssigmentRule()); } 
	 EOF 
;

// Rule UiMobileHorizontalLayoutAssigment
ruleUiMobileHorizontalLayoutAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileHorizontalLayoutAssigmentAccess().getGroup()); }
(rule__UiMobileHorizontalLayoutAssigment__Group__0)
{ after(grammarAccess.getUiMobileHorizontalLayoutAssigmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileHorizontalButtonGroup
entryRuleUiMobileHorizontalButtonGroup 
:
{ before(grammarAccess.getUiMobileHorizontalButtonGroupRule()); }
	 ruleUiMobileHorizontalButtonGroup
{ after(grammarAccess.getUiMobileHorizontalButtonGroupRule()); } 
	 EOF 
;

// Rule UiMobileHorizontalButtonGroup
ruleUiMobileHorizontalButtonGroup
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileHorizontalButtonGroupAccess().getGroup()); }
(rule__UiMobileHorizontalButtonGroup__Group__0)
{ after(grammarAccess.getUiMobileHorizontalButtonGroupAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileHorizontalButtonGroupAssigment
entryRuleUiMobileHorizontalButtonGroupAssigment 
:
{ before(grammarAccess.getUiMobileHorizontalButtonGroupAssigmentRule()); }
	 ruleUiMobileHorizontalButtonGroupAssigment
{ after(grammarAccess.getUiMobileHorizontalButtonGroupAssigmentRule()); } 
	 EOF 
;

// Rule UiMobileHorizontalButtonGroupAssigment
ruleUiMobileHorizontalButtonGroupAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileHorizontalButtonGroupAssigmentAccess().getElementAssignment()); }
(rule__UiMobileHorizontalButtonGroupAssigment__ElementAssignment)
{ after(grammarAccess.getUiMobileHorizontalButtonGroupAssigmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileVerticalComponentGroup
entryRuleUiMobileVerticalComponentGroup 
:
{ before(grammarAccess.getUiMobileVerticalComponentGroupRule()); }
	 ruleUiMobileVerticalComponentGroup
{ after(grammarAccess.getUiMobileVerticalComponentGroupRule()); } 
	 EOF 
;

// Rule UiMobileVerticalComponentGroup
ruleUiMobileVerticalComponentGroup
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileVerticalComponentGroupAccess().getGroup()); }
(rule__UiMobileVerticalComponentGroup__Group__0)
{ after(grammarAccess.getUiMobileVerticalComponentGroupAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileVerticalComponentGroupAssigment
entryRuleUiMobileVerticalComponentGroupAssigment 
:
{ before(grammarAccess.getUiMobileVerticalComponentGroupAssigmentRule()); }
	 ruleUiMobileVerticalComponentGroupAssigment
{ after(grammarAccess.getUiMobileVerticalComponentGroupAssigmentRule()); } 
	 EOF 
;

// Rule UiMobileVerticalComponentGroupAssigment
ruleUiMobileVerticalComponentGroupAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileVerticalComponentGroupAssigmentAccess().getElementAssignment()); }
(rule__UiMobileVerticalComponentGroupAssigment__ElementAssignment)
{ after(grammarAccess.getUiMobileVerticalComponentGroupAssigmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSearchPanel
entryRuleUiSearchPanel 
:
{ before(grammarAccess.getUiSearchPanelRule()); }
	 ruleUiSearchPanel
{ after(grammarAccess.getUiSearchPanelRule()); } 
	 EOF 
;

// Rule UiSearchPanel
ruleUiSearchPanel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSearchPanelAccess().getGroup()); }
(rule__UiSearchPanel__Group__0)
{ after(grammarAccess.getUiSearchPanelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileSearchPanel
entryRuleUiMobileSearchPanel 
:
{ before(grammarAccess.getUiMobileSearchPanelRule()); }
	 ruleUiMobileSearchPanel
{ after(grammarAccess.getUiMobileSearchPanelRule()); } 
	 EOF 
;

// Rule UiMobileSearchPanel
ruleUiMobileSearchPanel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileSearchPanelAccess().getGroup()); }
(rule__UiMobileSearchPanel__Group__0)
{ after(grammarAccess.getUiMobileSearchPanelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileTabSheet
entryRuleUiMobileTabSheet 
:
{ before(grammarAccess.getUiMobileTabSheetRule()); }
	 ruleUiMobileTabSheet
{ after(grammarAccess.getUiMobileTabSheetRule()); } 
	 EOF 
;

// Rule UiMobileTabSheet
ruleUiMobileTabSheet
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileTabSheetAccess().getGroup()); }
(rule__UiMobileTabSheet__Group__0)
{ after(grammarAccess.getUiMobileTabSheetAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileTabAssignment
entryRuleUiMobileTabAssignment 
:
{ before(grammarAccess.getUiMobileTabAssignmentRule()); }
	 ruleUiMobileTabAssignment
{ after(grammarAccess.getUiMobileTabAssignmentRule()); } 
	 EOF 
;

// Rule UiMobileTabAssignment
ruleUiMobileTabAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileTabAssignmentAccess().getGroup()); }
(rule__UiMobileTabAssignment__Group__0)
{ after(grammarAccess.getUiMobileTabAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTabSheet
entryRuleUiTabSheet 
:
{ before(grammarAccess.getUiTabSheetRule()); }
	 ruleUiTabSheet
{ after(grammarAccess.getUiTabSheetRule()); } 
	 EOF 
;

// Rule UiTabSheet
ruleUiTabSheet
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTabSheetAccess().getGroup()); }
(rule__UiTabSheet__Group__0)
{ after(grammarAccess.getUiTabSheetAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTabAssignment
entryRuleUiTabAssignment 
:
{ before(grammarAccess.getUiTabAssignmentRule()); }
	 ruleUiTabAssignment
{ after(grammarAccess.getUiTabAssignmentRule()); } 
	 EOF 
;

// Rule UiTabAssignment
ruleUiTabAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTabAssignmentAccess().getGroup()); }
(rule__UiTabAssignment__Group__0)
{ after(grammarAccess.getUiTabAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSplitpanel
entryRuleUiSplitpanel 
:
{ before(grammarAccess.getUiSplitpanelRule()); }
	 ruleUiSplitpanel
{ after(grammarAccess.getUiSplitpanelRule()); } 
	 EOF 
;

// Rule UiSplitpanel
ruleUiSplitpanel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSplitpanelAccess().getGroup()); }
(rule__UiSplitpanel__Group__0)
{ after(grammarAccess.getUiSplitpanelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSplitpanelAssigment
entryRuleUiSplitpanelAssigment 
:
{ before(grammarAccess.getUiSplitpanelAssigmentRule()); }
	 ruleUiSplitpanelAssigment
{ after(grammarAccess.getUiSplitpanelAssigmentRule()); } 
	 EOF 
;

// Rule UiSplitpanelAssigment
ruleUiSplitpanelAssigment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSplitpanelAssigmentAccess().getElementAssignment()); }
(rule__UiSplitpanelAssigment__ElementAssignment)
{ after(grammarAccess.getUiSplitpanelAssigmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiPanel
entryRuleUiPanel 
:
{ before(grammarAccess.getUiPanelRule()); }
	 ruleUiPanel
{ after(grammarAccess.getUiPanelRule()); } 
	 EOF 
;

// Rule UiPanel
ruleUiPanel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiPanelAccess().getGroup()); }
(rule__UiPanel__Group__0)
{ after(grammarAccess.getUiPanelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiDialog
entryRuleUiDialog 
:
{ before(grammarAccess.getUiDialogRule()); }
	 ruleUiDialog
{ after(grammarAccess.getUiDialogRule()); } 
	 EOF 
;

// Rule UiDialog
ruleUiDialog
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiDialogAccess().getGroup()); }
(rule__UiDialog__Group__0)
{ after(grammarAccess.getUiDialogAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiDialogAssignment
entryRuleUiDialogAssignment 
:
{ before(grammarAccess.getUiDialogAssignmentRule()); }
	 ruleUiDialogAssignment
{ after(grammarAccess.getUiDialogAssignmentRule()); } 
	 EOF 
;

// Rule UiDialogAssignment
ruleUiDialogAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiDialogAssignmentAccess().getElementAssignment()); }
(rule__UiDialogAssignment__ElementAssignment)
{ after(grammarAccess.getUiDialogAssignmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSearchDialog
entryRuleUiSearchDialog 
:
{ before(grammarAccess.getUiSearchDialogRule()); }
	 ruleUiSearchDialog
{ after(grammarAccess.getUiSearchDialogRule()); } 
	 EOF 
;

// Rule UiSearchDialog
ruleUiSearchDialog
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSearchDialogAccess().getGroup()); }
(rule__UiSearchDialog__Group__0)
{ after(grammarAccess.getUiSearchDialogAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiDialogSearchFieldAssignment
entryRuleUiDialogSearchFieldAssignment 
:
{ before(grammarAccess.getUiDialogSearchFieldAssignmentRule()); }
	 ruleUiDialogSearchFieldAssignment
{ after(grammarAccess.getUiDialogSearchFieldAssignmentRule()); } 
	 EOF 
;

// Rule UiDialogSearchFieldAssignment
ruleUiDialogSearchFieldAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiDialogSearchFieldAssignmentAccess().getElementAssignment()); }
(rule__UiDialogSearchFieldAssignment__ElementAssignment)
{ after(grammarAccess.getUiDialogSearchFieldAssignmentAccess().getElementAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavigationPage
entryRuleUiMobileNavigationPage 
:
{ before(grammarAccess.getUiMobileNavigationPageRule()); }
	 ruleUiMobileNavigationPage
{ after(grammarAccess.getUiMobileNavigationPageRule()); } 
	 EOF 
;

// Rule UiMobileNavigationPage
ruleUiMobileNavigationPage
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavigationPageAccess().getGroup()); }
(rule__UiMobileNavigationPage__Group__0)
{ after(grammarAccess.getUiMobileNavigationPageAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavigationPageAssignment
entryRuleUiMobileNavigationPageAssignment 
:
{ before(grammarAccess.getUiMobileNavigationPageAssignmentRule()); }
	 ruleUiMobileNavigationPageAssignment
{ after(grammarAccess.getUiMobileNavigationPageAssignmentRule()); } 
	 EOF 
;

// Rule UiMobileNavigationPageAssignment
ruleUiMobileNavigationPageAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavigationPageAssignmentAccess().getGroup()); }
(rule__UiMobileNavigationPageAssignment__Group__0)
{ after(grammarAccess.getUiMobileNavigationPageAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleUiTextField
entryRuleUiTextField 
:
{ before(grammarAccess.getUiTextFieldRule()); }
	 ruleUiTextField
{ after(grammarAccess.getUiTextFieldRule()); } 
	 EOF 
;

// Rule UiTextField
ruleUiTextField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTextFieldAccess().getGroup()); }
(rule__UiTextField__Group__0)
{ after(grammarAccess.getUiTextFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiPasswordField
entryRuleUiPasswordField 
:
{ before(grammarAccess.getUiPasswordFieldRule()); }
	 ruleUiPasswordField
{ after(grammarAccess.getUiPasswordFieldRule()); } 
	 EOF 
;

// Rule UiPasswordField
ruleUiPasswordField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiPasswordFieldAccess().getGroup()); }
(rule__UiPasswordField__Group__0)
{ after(grammarAccess.getUiPasswordFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMaskedTextField
entryRuleUiMaskedTextField 
:
{ before(grammarAccess.getUiMaskedTextFieldRule()); }
	 ruleUiMaskedTextField
{ after(grammarAccess.getUiMaskedTextFieldRule()); } 
	 EOF 
;

// Rule UiMaskedTextField
ruleUiMaskedTextField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMaskedTextFieldAccess().getGroup()); }
(rule__UiMaskedTextField__Group__0)
{ after(grammarAccess.getUiMaskedTextFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMaskedNumericField
entryRuleUiMaskedNumericField 
:
{ before(grammarAccess.getUiMaskedNumericFieldRule()); }
	 ruleUiMaskedNumericField
{ after(grammarAccess.getUiMaskedNumericFieldRule()); } 
	 EOF 
;

// Rule UiMaskedNumericField
ruleUiMaskedNumericField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMaskedNumericFieldAccess().getGroup()); }
(rule__UiMaskedNumericField__Group__0)
{ after(grammarAccess.getUiMaskedNumericFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMaskedDecimalField
entryRuleUiMaskedDecimalField 
:
{ before(grammarAccess.getUiMaskedDecimalFieldRule()); }
	 ruleUiMaskedDecimalField
{ after(grammarAccess.getUiMaskedDecimalFieldRule()); } 
	 EOF 
;

// Rule UiMaskedDecimalField
ruleUiMaskedDecimalField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMaskedDecimalFieldAccess().getGroup()); }
(rule__UiMaskedDecimalField__Group__0)
{ after(grammarAccess.getUiMaskedDecimalFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiPrefixedMaskedTextField
entryRuleUiPrefixedMaskedTextField 
:
{ before(grammarAccess.getUiPrefixedMaskedTextFieldRule()); }
	 ruleUiPrefixedMaskedTextField
{ after(grammarAccess.getUiPrefixedMaskedTextFieldRule()); } 
	 EOF 
;

// Rule UiPrefixedMaskedTextField
ruleUiPrefixedMaskedTextField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiPrefixedMaskedTextFieldAccess().getGroup()); }
(rule__UiPrefixedMaskedTextField__Group__0)
{ after(grammarAccess.getUiPrefixedMaskedTextFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiPrefixToMaskMapEntry
entryRuleUiPrefixToMaskMapEntry 
:
{ before(grammarAccess.getUiPrefixToMaskMapEntryRule()); }
	 ruleUiPrefixToMaskMapEntry
{ after(grammarAccess.getUiPrefixToMaskMapEntryRule()); } 
	 EOF 
;

// Rule UiPrefixToMaskMapEntry
ruleUiPrefixToMaskMapEntry
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiPrefixToMaskMapEntryAccess().getGroup()); }
(rule__UiPrefixToMaskMapEntry__Group__0)
{ after(grammarAccess.getUiPrefixToMaskMapEntryAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiRichTextArea
entryRuleUiRichTextArea 
:
{ before(grammarAccess.getUiRichTextAreaRule()); }
	 ruleUiRichTextArea
{ after(grammarAccess.getUiRichTextAreaRule()); } 
	 EOF 
;

// Rule UiRichTextArea
ruleUiRichTextArea
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiRichTextAreaAccess().getGroup()); }
(rule__UiRichTextArea__Group__0)
{ after(grammarAccess.getUiRichTextAreaAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSuggestTextField
entryRuleUiSuggestTextField 
:
{ before(grammarAccess.getUiSuggestTextFieldRule()); }
	 ruleUiSuggestTextField
{ after(grammarAccess.getUiSuggestTextFieldRule()); } 
	 EOF 
;

// Rule UiSuggestTextField
ruleUiSuggestTextField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSuggestTextFieldAccess().getGroup()); }
(rule__UiSuggestTextField__Group__0)
{ after(grammarAccess.getUiSuggestTextFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBeanReferenceField
entryRuleUiBeanReferenceField 
:
{ before(grammarAccess.getUiBeanReferenceFieldRule()); }
	 ruleUiBeanReferenceField
{ after(grammarAccess.getUiBeanReferenceFieldRule()); } 
	 EOF 
;

// Rule UiBeanReferenceField
ruleUiBeanReferenceField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBeanReferenceFieldAccess().getGroup()); }
(rule__UiBeanReferenceField__Group__0)
{ after(grammarAccess.getUiBeanReferenceFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSearchField
entryRuleUiSearchField 
:
{ before(grammarAccess.getUiSearchFieldRule()); }
	 ruleUiSearchField
{ after(grammarAccess.getUiSearchFieldRule()); } 
	 EOF 
;

// Rule UiSearchField
ruleUiSearchField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSearchFieldAccess().getGroup()); }
(rule__UiSearchField__Group__0)
{ after(grammarAccess.getUiSearchFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTextArea
entryRuleUiTextArea 
:
{ before(grammarAccess.getUiTextAreaRule()); }
	 ruleUiTextArea
{ after(grammarAccess.getUiTextAreaRule()); } 
	 EOF 
;

// Rule UiTextArea
ruleUiTextArea
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTextAreaAccess().getGroup()); }
(rule__UiTextArea__Group__0)
{ after(grammarAccess.getUiTextAreaAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiDateField
entryRuleUiDateField 
:
{ before(grammarAccess.getUiDateFieldRule()); }
	 ruleUiDateField
{ after(grammarAccess.getUiDateFieldRule()); } 
	 EOF 
;

// Rule UiDateField
ruleUiDateField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiDateFieldAccess().getGroup()); }
(rule__UiDateField__Group__0)
{ after(grammarAccess.getUiDateFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBrowser
entryRuleUiBrowser 
:
{ before(grammarAccess.getUiBrowserRule()); }
	 ruleUiBrowser
{ after(grammarAccess.getUiBrowserRule()); } 
	 EOF 
;

// Rule UiBrowser
ruleUiBrowser
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBrowserAccess().getGroup()); }
(rule__UiBrowser__Group__0)
{ after(grammarAccess.getUiBrowserAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiProgressBar
entryRuleUiProgressBar 
:
{ before(grammarAccess.getUiProgressBarRule()); }
	 ruleUiProgressBar
{ after(grammarAccess.getUiProgressBarRule()); } 
	 EOF 
;

// Rule UiProgressBar
ruleUiProgressBar
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiProgressBarAccess().getGroup()); }
(rule__UiProgressBar__Group__0)
{ after(grammarAccess.getUiProgressBarAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiImage
entryRuleUiImage 
:
{ before(grammarAccess.getUiImageRule()); }
	 ruleUiImage
{ after(grammarAccess.getUiImageRule()); } 
	 EOF 
;

// Rule UiImage
ruleUiImage
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiImageAccess().getGroup()); }
(rule__UiImage__Group__0)
{ after(grammarAccess.getUiImageAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiTable
entryRuleUiTable 
:
{ before(grammarAccess.getUiTableRule()); }
	 ruleUiTable
{ after(grammarAccess.getUiTableRule()); } 
	 EOF 
;

// Rule UiTable
ruleUiTable
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiTableAccess().getGroup()); }
(rule__UiTable__Group__0)
{ after(grammarAccess.getUiTableAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiComboBox
entryRuleUiComboBox 
:
{ before(grammarAccess.getUiComboBoxRule()); }
	 ruleUiComboBox
{ after(grammarAccess.getUiComboBoxRule()); } 
	 EOF 
;

// Rule UiComboBox
ruleUiComboBox
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiComboBoxAccess().getGroup()); }
(rule__UiComboBox__Group__0)
{ after(grammarAccess.getUiComboBoxAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiButton
entryRuleUiButton 
:
{ before(grammarAccess.getUiButtonRule()); }
	 ruleUiButton
{ after(grammarAccess.getUiButtonRule()); } 
	 EOF 
;

// Rule UiButton
ruleUiButton
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiButtonAccess().getGroup()); }
(rule__UiButton__Group__0)
{ after(grammarAccess.getUiButtonAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileNavigationButton
entryRuleUiMobileNavigationButton 
:
{ before(grammarAccess.getUiMobileNavigationButtonRule()); }
	 ruleUiMobileNavigationButton
{ after(grammarAccess.getUiMobileNavigationButtonRule()); } 
	 EOF 
;

// Rule UiMobileNavigationButton
ruleUiMobileNavigationButton
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileNavigationButtonAccess().getGroup()); }
(rule__UiMobileNavigationButton__Group__0)
{ after(grammarAccess.getUiMobileNavigationButtonAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileSwitch
entryRuleUiMobileSwitch 
:
{ before(grammarAccess.getUiMobileSwitchRule()); }
	 ruleUiMobileSwitch
{ after(grammarAccess.getUiMobileSwitchRule()); } 
	 EOF 
;

// Rule UiMobileSwitch
ruleUiMobileSwitch
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileSwitchAccess().getGroup()); }
(rule__UiMobileSwitch__Group__0)
{ after(grammarAccess.getUiMobileSwitchAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiLabel
entryRuleUiLabel 
:
{ before(grammarAccess.getUiLabelRule()); }
	 ruleUiLabel
{ after(grammarAccess.getUiLabelRule()); } 
	 EOF 
;

// Rule UiLabel
ruleUiLabel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiLabelAccess().getGroup()); }
(rule__UiLabel__Group__0)
{ after(grammarAccess.getUiLabelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiDecimalField
entryRuleUiDecimalField 
:
{ before(grammarAccess.getUiDecimalFieldRule()); }
	 ruleUiDecimalField
{ after(grammarAccess.getUiDecimalFieldRule()); } 
	 EOF 
;

// Rule UiDecimalField
ruleUiDecimalField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiDecimalFieldAccess().getGroup()); }
(rule__UiDecimalField__Group__0)
{ after(grammarAccess.getUiDecimalFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiOptionsGroup
entryRuleUiOptionsGroup 
:
{ before(grammarAccess.getUiOptionsGroupRule()); }
	 ruleUiOptionsGroup
{ after(grammarAccess.getUiOptionsGroupRule()); } 
	 EOF 
;

// Rule UiOptionsGroup
ruleUiOptionsGroup
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiOptionsGroupAccess().getGroup()); }
(rule__UiOptionsGroup__Group__0)
{ after(grammarAccess.getUiOptionsGroupAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiList
entryRuleUiList 
:
{ before(grammarAccess.getUiListRule()); }
	 ruleUiList
{ after(grammarAccess.getUiListRule()); } 
	 EOF 
;

// Rule UiList
ruleUiList
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiListAccess().getGroup()); }
(rule__UiList__Group__0)
{ after(grammarAccess.getUiListAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiColumnsAssignment
entryRuleUiColumnsAssignment 
:
{ before(grammarAccess.getUiColumnsAssignmentRule()); }
	 ruleUiColumnsAssignment
{ after(grammarAccess.getUiColumnsAssignmentRule()); } 
	 EOF 
;

// Rule UiColumnsAssignment
ruleUiColumnsAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiColumnsAssignmentAccess().getGroup()); }
(rule__UiColumnsAssignment__Group__0)
{ after(grammarAccess.getUiColumnsAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSortOrderAssignment
entryRuleUiSortOrderAssignment 
:
{ before(grammarAccess.getUiSortOrderAssignmentRule()); }
	 ruleUiSortOrderAssignment
{ after(grammarAccess.getUiSortOrderAssignmentRule()); } 
	 EOF 
;

// Rule UiSortOrderAssignment
ruleUiSortOrderAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSortOrderAssignmentAccess().getGroup()); }
(rule__UiSortOrderAssignment__Group__0)
{ after(grammarAccess.getUiSortOrderAssignmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiSortOrder
entryRuleUiSortOrder 
:
{ before(grammarAccess.getUiSortOrderRule()); }
	 ruleUiSortOrder
{ after(grammarAccess.getUiSortOrderRule()); } 
	 EOF 
;

// Rule UiSortOrder
ruleUiSortOrder
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiSortOrderAccess().getGroup()); }
(rule__UiSortOrder__Group__0)
{ after(grammarAccess.getUiSortOrderAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiColumn
entryRuleUiColumn 
:
{ before(grammarAccess.getUiColumnRule()); }
	 ruleUiColumn
{ after(grammarAccess.getUiColumnRule()); } 
	 EOF 
;

// Rule UiColumn
ruleUiColumn
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiColumnAccess().getGroup()); }
(rule__UiColumn__Group__0)
{ after(grammarAccess.getUiColumnAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiEmbeddable
entryRuleUiEmbeddable 
:
{ before(grammarAccess.getUiEmbeddableRule()); }
	 ruleUiEmbeddable
{ after(grammarAccess.getUiEmbeddableRule()); } 
	 EOF 
;

// Rule UiEmbeddable
ruleUiEmbeddable
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiEmbeddableAccess().getAlternatives()); }
(rule__UiEmbeddable__Alternatives)
{ after(grammarAccess.getUiEmbeddableAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileEmbeddable
entryRuleUiMobileEmbeddable 
:
{ before(grammarAccess.getUiMobileEmbeddableRule()); }
	 ruleUiMobileEmbeddable
{ after(grammarAccess.getUiMobileEmbeddableRule()); } 
	 EOF 
;

// Rule UiMobileEmbeddable
ruleUiMobileEmbeddable
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileEmbeddableAccess().getAlternatives()); }
(rule__UiMobileEmbeddable__Alternatives)
{ after(grammarAccess.getUiMobileEmbeddableAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileLayout
entryRuleUiMobileLayout 
:
{ before(grammarAccess.getUiMobileLayoutRule()); }
	 ruleUiMobileLayout
{ after(grammarAccess.getUiMobileLayoutRule()); } 
	 EOF 
;

// Rule UiMobileLayout
ruleUiMobileLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileLayoutAccess().getAlternatives()); }
(rule__UiMobileLayout__Alternatives)
{ after(grammarAccess.getUiMobileLayoutAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileField
entryRuleUiMobileField 
:
{ before(grammarAccess.getUiMobileFieldRule()); }
	 ruleUiMobileField
{ after(grammarAccess.getUiMobileFieldRule()); } 
	 EOF 
;

// Rule UiMobileField
ruleUiMobileField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileFieldAccess().getAlternatives()); }
(rule__UiMobileField__Alternatives)
{ after(grammarAccess.getUiMobileFieldAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiLayout
entryRuleUiLayout 
:
{ before(grammarAccess.getUiLayoutRule()); }
	 ruleUiLayout
{ after(grammarAccess.getUiLayoutRule()); } 
	 EOF 
;

// Rule UiLayout
ruleUiLayout
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiLayoutAccess().getAlternatives()); }
(rule__UiLayout__Alternatives)
{ after(grammarAccess.getUiLayoutAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiField
entryRuleUiField 
:
{ before(grammarAccess.getUiFieldRule()); }
	 ruleUiField
{ after(grammarAccess.getUiFieldRule()); } 
	 EOF 
;

// Rule UiField
ruleUiField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiFieldAccess().getAlternatives()); }
(rule__UiField__Alternatives)
{ after(grammarAccess.getUiFieldAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiAction
entryRuleUiAction 
:
{ before(grammarAccess.getUiActionRule()); }
	 ruleUiAction
{ after(grammarAccess.getUiActionRule()); } 
	 EOF 
;

// Rule UiAction
ruleUiAction
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiActionAccess().getUiButtonParserRuleCall()); }
	ruleUiButton
{ after(grammarAccess.getUiActionAccess().getUiButtonParserRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMobileAction
entryRuleUiMobileAction 
:
{ before(grammarAccess.getUiMobileActionRule()); }
	 ruleUiMobileAction
{ after(grammarAccess.getUiMobileActionRule()); } 
	 EOF 
;

// Rule UiMobileAction
ruleUiMobileAction
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMobileActionAccess().getAlternatives()); }
(rule__UiMobileAction__Alternatives)
{ after(grammarAccess.getUiMobileActionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiNumericField
entryRuleUiNumericField 
:
{ before(grammarAccess.getUiNumericFieldRule()); }
	 ruleUiNumericField
{ after(grammarAccess.getUiNumericFieldRule()); } 
	 EOF 
;

// Rule UiNumericField
ruleUiNumericField
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiNumericFieldAccess().getGroup()); }
(rule__UiNumericField__Group__0)
{ after(grammarAccess.getUiNumericFieldAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiCheckBox
entryRuleUiCheckBox 
:
{ before(grammarAccess.getUiCheckBoxRule()); }
	 ruleUiCheckBox
{ after(grammarAccess.getUiCheckBoxRule()); } 
	 EOF 
;

// Rule UiCheckBox
ruleUiCheckBox
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiCheckBoxAccess().getGroup()); }
(rule__UiCheckBox__Group__0)
{ after(grammarAccess.getUiCheckBoxAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiValidator
entryRuleUiValidator 
:
{ before(grammarAccess.getUiValidatorRule()); }
	 ruleUiValidator
{ after(grammarAccess.getUiValidatorRule()); } 
	 EOF 
;

// Rule UiValidator
ruleUiValidator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiValidatorAccess().getAlternatives()); }
(rule__UiValidator__Alternatives)
{ after(grammarAccess.getUiValidatorAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMaxLengthValidator
entryRuleUiMaxLengthValidator 
:
{ before(grammarAccess.getUiMaxLengthValidatorRule()); }
	 ruleUiMaxLengthValidator
{ after(grammarAccess.getUiMaxLengthValidatorRule()); } 
	 EOF 
;

// Rule UiMaxLengthValidator
ruleUiMaxLengthValidator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMaxLengthValidatorAccess().getGroup()); }
(rule__UiMaxLengthValidator__Group__0)
{ after(grammarAccess.getUiMaxLengthValidatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiMinLengthValidator
entryRuleUiMinLengthValidator 
:
{ before(grammarAccess.getUiMinLengthValidatorRule()); }
	 ruleUiMinLengthValidator
{ after(grammarAccess.getUiMinLengthValidatorRule()); } 
	 EOF 
;

// Rule UiMinLengthValidator
ruleUiMinLengthValidator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiMinLengthValidatorAccess().getGroup()); }
(rule__UiMinLengthValidator__Group__0)
{ after(grammarAccess.getUiMinLengthValidatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiRegexpValidator
entryRuleUiRegexpValidator 
:
{ before(grammarAccess.getUiRegexpValidatorRule()); }
	 ruleUiRegexpValidator
{ after(grammarAccess.getUiRegexpValidatorRule()); } 
	 EOF 
;

// Rule UiRegexpValidator
ruleUiRegexpValidator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiRegexpValidatorAccess().getGroup()); }
(rule__UiRegexpValidator__Group__0)
{ after(grammarAccess.getUiRegexpValidatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiXbaseValidator
entryRuleUiXbaseValidator 
:
{ before(grammarAccess.getUiXbaseValidatorRule()); }
	 ruleUiXbaseValidator
{ after(grammarAccess.getUiXbaseValidatorRule()); } 
	 EOF 
;

// Rule UiXbaseValidator
ruleUiXbaseValidator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiXbaseValidatorAccess().getGroup()); }
(rule__UiXbaseValidator__Group__0)
{ after(grammarAccess.getUiXbaseValidatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiBeanValidationValidator
entryRuleUiBeanValidationValidator 
:
{ before(grammarAccess.getUiBeanValidationValidatorRule()); }
	 ruleUiBeanValidationValidator
{ after(grammarAccess.getUiBeanValidationValidatorRule()); } 
	 EOF 
;

// Rule UiBeanValidationValidator
ruleUiBeanValidationValidator
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiBeanValidationValidatorAccess().getGroup()); }
(rule__UiBeanValidationValidator__Group__0)
{ after(grammarAccess.getUiBeanValidationValidatorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiErrorCode
entryRuleUiErrorCode 
:
{ before(grammarAccess.getUiErrorCodeRule()); }
	 ruleUiErrorCode
{ after(grammarAccess.getUiErrorCodeRule()); } 
	 EOF 
;

// Rule UiErrorCode
ruleUiErrorCode
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiErrorCodeAccess().getGroup()); }
(rule__UiErrorCode__Group__0)
{ after(grammarAccess.getUiErrorCodeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiVisibilityProcessor
entryRuleUiVisibilityProcessor 
:
{ before(grammarAccess.getUiVisibilityProcessorRule()); }
	 ruleUiVisibilityProcessor
{ after(grammarAccess.getUiVisibilityProcessorRule()); } 
	 EOF 
;

// Rule UiVisibilityProcessor
ruleUiVisibilityProcessor
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiVisibilityProcessorAccess().getGroup()); }
(rule__UiVisibilityProcessor__Group__0)
{ after(grammarAccess.getUiVisibilityProcessorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiXbaseVisibilityRule
entryRuleUiXbaseVisibilityRule 
:
{ before(grammarAccess.getUiXbaseVisibilityRuleRule()); }
	 ruleUiXbaseVisibilityRule
{ after(grammarAccess.getUiXbaseVisibilityRuleRule()); } 
	 EOF 
;

// Rule UiXbaseVisibilityRule
ruleUiXbaseVisibilityRule
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiXbaseVisibilityRuleAccess().getExpressionAssignment()); }
(rule__UiXbaseVisibilityRule__ExpressionAssignment)
{ after(grammarAccess.getUiXbaseVisibilityRuleAccess().getExpressionAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleUiChangeTrigger
entryRuleUiChangeTrigger 
:
{ before(grammarAccess.getUiChangeTriggerRule()); }
	 ruleUiChangeTrigger
{ after(grammarAccess.getUiChangeTriggerRule()); } 
	 EOF 
;

// Rule UiChangeTrigger
ruleUiChangeTrigger
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getUiChangeTriggerAccess().getGroup()); }
(rule__UiChangeTrigger__Group__0)
{ after(grammarAccess.getUiChangeTriggerAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXExpression
entryRuleXExpression 
:
{ before(grammarAccess.getXExpressionRule()); }
	 ruleXExpression
{ after(grammarAccess.getXExpressionRule()); } 
	 EOF 
;

// Rule XExpression
ruleXExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
	ruleXAssignment
{ after(grammarAccess.getXExpressionAccess().getXAssignmentParserRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXAssignment
entryRuleXAssignment 
:
{ before(grammarAccess.getXAssignmentRule()); }
	 ruleXAssignment
{ after(grammarAccess.getXAssignmentRule()); } 
	 EOF 
;

// Rule XAssignment
ruleXAssignment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXAssignmentAccess().getAlternatives()); }
(rule__XAssignment__Alternatives)
{ after(grammarAccess.getXAssignmentAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpSingleAssign
entryRuleOpSingleAssign 
:
{ before(grammarAccess.getOpSingleAssignRule()); }
	 ruleOpSingleAssign
{ after(grammarAccess.getOpSingleAssignRule()); } 
	 EOF 
;

// Rule OpSingleAssign
ruleOpSingleAssign
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }

	'=' 

{ after(grammarAccess.getOpSingleAssignAccess().getEqualsSignKeyword()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpMultiAssign
entryRuleOpMultiAssign 
:
{ before(grammarAccess.getOpMultiAssignRule()); }
	 ruleOpMultiAssign
{ after(grammarAccess.getOpMultiAssignRule()); } 
	 EOF 
;

// Rule OpMultiAssign
ruleOpMultiAssign
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
(rule__OpMultiAssign__Alternatives)
{ after(grammarAccess.getOpMultiAssignAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXOrExpression
entryRuleXOrExpression 
:
{ before(grammarAccess.getXOrExpressionRule()); }
	 ruleXOrExpression
{ after(grammarAccess.getXOrExpressionRule()); } 
	 EOF 
;

// Rule XOrExpression
ruleXOrExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXOrExpressionAccess().getGroup()); }
(rule__XOrExpression__Group__0)
{ after(grammarAccess.getXOrExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpOr
entryRuleOpOr 
:
{ before(grammarAccess.getOpOrRule()); }
	 ruleOpOr
{ after(grammarAccess.getOpOrRule()); } 
	 EOF 
;

// Rule OpOr
ruleOpOr
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }

	'||' 

{ after(grammarAccess.getOpOrAccess().getVerticalLineVerticalLineKeyword()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXAndExpression
entryRuleXAndExpression 
:
{ before(grammarAccess.getXAndExpressionRule()); }
	 ruleXAndExpression
{ after(grammarAccess.getXAndExpressionRule()); } 
	 EOF 
;

// Rule XAndExpression
ruleXAndExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXAndExpressionAccess().getGroup()); }
(rule__XAndExpression__Group__0)
{ after(grammarAccess.getXAndExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpAnd
entryRuleOpAnd 
:
{ before(grammarAccess.getOpAndRule()); }
	 ruleOpAnd
{ after(grammarAccess.getOpAndRule()); } 
	 EOF 
;

// Rule OpAnd
ruleOpAnd
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }

	'&&' 

{ after(grammarAccess.getOpAndAccess().getAmpersandAmpersandKeyword()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXEqualityExpression
entryRuleXEqualityExpression 
:
{ before(grammarAccess.getXEqualityExpressionRule()); }
	 ruleXEqualityExpression
{ after(grammarAccess.getXEqualityExpressionRule()); } 
	 EOF 
;

// Rule XEqualityExpression
ruleXEqualityExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
(rule__XEqualityExpression__Group__0)
{ after(grammarAccess.getXEqualityExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpEquality
entryRuleOpEquality 
:
{ before(grammarAccess.getOpEqualityRule()); }
	 ruleOpEquality
{ after(grammarAccess.getOpEqualityRule()); } 
	 EOF 
;

// Rule OpEquality
ruleOpEquality
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpEqualityAccess().getAlternatives()); }
(rule__OpEquality__Alternatives)
{ after(grammarAccess.getOpEqualityAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXRelationalExpression
entryRuleXRelationalExpression 
:
{ before(grammarAccess.getXRelationalExpressionRule()); }
	 ruleXRelationalExpression
{ after(grammarAccess.getXRelationalExpressionRule()); } 
	 EOF 
;

// Rule XRelationalExpression
ruleXRelationalExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
(rule__XRelationalExpression__Group__0)
{ after(grammarAccess.getXRelationalExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpCompare
entryRuleOpCompare 
:
{ before(grammarAccess.getOpCompareRule()); }
	 ruleOpCompare
{ after(grammarAccess.getOpCompareRule()); } 
	 EOF 
;

// Rule OpCompare
ruleOpCompare
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpCompareAccess().getAlternatives()); }
(rule__OpCompare__Alternatives)
{ after(grammarAccess.getOpCompareAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXOtherOperatorExpression
entryRuleXOtherOperatorExpression 
:
{ before(grammarAccess.getXOtherOperatorExpressionRule()); }
	 ruleXOtherOperatorExpression
{ after(grammarAccess.getXOtherOperatorExpressionRule()); } 
	 EOF 
;

// Rule XOtherOperatorExpression
ruleXOtherOperatorExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
(rule__XOtherOperatorExpression__Group__0)
{ after(grammarAccess.getXOtherOperatorExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpOther
entryRuleOpOther 
:
{ before(grammarAccess.getOpOtherRule()); }
	 ruleOpOther
{ after(grammarAccess.getOpOtherRule()); } 
	 EOF 
;

// Rule OpOther
ruleOpOther
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpOtherAccess().getAlternatives()); }
(rule__OpOther__Alternatives)
{ after(grammarAccess.getOpOtherAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXAdditiveExpression
entryRuleXAdditiveExpression 
:
{ before(grammarAccess.getXAdditiveExpressionRule()); }
	 ruleXAdditiveExpression
{ after(grammarAccess.getXAdditiveExpressionRule()); } 
	 EOF 
;

// Rule XAdditiveExpression
ruleXAdditiveExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
(rule__XAdditiveExpression__Group__0)
{ after(grammarAccess.getXAdditiveExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpAdd
entryRuleOpAdd 
:
{ before(grammarAccess.getOpAddRule()); }
	 ruleOpAdd
{ after(grammarAccess.getOpAddRule()); } 
	 EOF 
;

// Rule OpAdd
ruleOpAdd
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpAddAccess().getAlternatives()); }
(rule__OpAdd__Alternatives)
{ after(grammarAccess.getOpAddAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXMultiplicativeExpression
entryRuleXMultiplicativeExpression 
:
{ before(grammarAccess.getXMultiplicativeExpressionRule()); }
	 ruleXMultiplicativeExpression
{ after(grammarAccess.getXMultiplicativeExpressionRule()); } 
	 EOF 
;

// Rule XMultiplicativeExpression
ruleXMultiplicativeExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
(rule__XMultiplicativeExpression__Group__0)
{ after(grammarAccess.getXMultiplicativeExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpMulti
entryRuleOpMulti 
:
{ before(grammarAccess.getOpMultiRule()); }
	 ruleOpMulti
{ after(grammarAccess.getOpMultiRule()); } 
	 EOF 
;

// Rule OpMulti
ruleOpMulti
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpMultiAccess().getAlternatives()); }
(rule__OpMulti__Alternatives)
{ after(grammarAccess.getOpMultiAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXUnaryOperation
entryRuleXUnaryOperation 
:
{ before(grammarAccess.getXUnaryOperationRule()); }
	 ruleXUnaryOperation
{ after(grammarAccess.getXUnaryOperationRule()); } 
	 EOF 
;

// Rule XUnaryOperation
ruleXUnaryOperation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
(rule__XUnaryOperation__Alternatives)
{ after(grammarAccess.getXUnaryOperationAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpUnary
entryRuleOpUnary 
:
{ before(grammarAccess.getOpUnaryRule()); }
	 ruleOpUnary
{ after(grammarAccess.getOpUnaryRule()); } 
	 EOF 
;

// Rule OpUnary
ruleOpUnary
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpUnaryAccess().getAlternatives()); }
(rule__OpUnary__Alternatives)
{ after(grammarAccess.getOpUnaryAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXCastedExpression
entryRuleXCastedExpression 
:
{ before(grammarAccess.getXCastedExpressionRule()); }
	 ruleXCastedExpression
{ after(grammarAccess.getXCastedExpressionRule()); } 
	 EOF 
;

// Rule XCastedExpression
ruleXCastedExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXCastedExpressionAccess().getGroup()); }
(rule__XCastedExpression__Group__0)
{ after(grammarAccess.getXCastedExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXPostfixOperation
entryRuleXPostfixOperation 
:
{ before(grammarAccess.getXPostfixOperationRule()); }
	 ruleXPostfixOperation
{ after(grammarAccess.getXPostfixOperationRule()); } 
	 EOF 
;

// Rule XPostfixOperation
ruleXPostfixOperation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXPostfixOperationAccess().getGroup()); }
(rule__XPostfixOperation__Group__0)
{ after(grammarAccess.getXPostfixOperationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOpPostfix
entryRuleOpPostfix 
:
{ before(grammarAccess.getOpPostfixRule()); }
	 ruleOpPostfix
{ after(grammarAccess.getOpPostfixRule()); } 
	 EOF 
;

// Rule OpPostfix
ruleOpPostfix
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOpPostfixAccess().getAlternatives()); }
(rule__OpPostfix__Alternatives)
{ after(grammarAccess.getOpPostfixAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXMemberFeatureCall
entryRuleXMemberFeatureCall 
:
{ before(grammarAccess.getXMemberFeatureCallRule()); }
	 ruleXMemberFeatureCall
{ after(grammarAccess.getXMemberFeatureCallRule()); } 
	 EOF 
;

// Rule XMemberFeatureCall
ruleXMemberFeatureCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
(rule__XMemberFeatureCall__Group__0)
{ after(grammarAccess.getXMemberFeatureCallAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXPrimaryExpression
entryRuleXPrimaryExpression 
:
{ before(grammarAccess.getXPrimaryExpressionRule()); }
	 ruleXPrimaryExpression
{ after(grammarAccess.getXPrimaryExpressionRule()); } 
	 EOF 
;

// Rule XPrimaryExpression
ruleXPrimaryExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
(rule__XPrimaryExpression__Alternatives)
{ after(grammarAccess.getXPrimaryExpressionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXLiteral
entryRuleXLiteral 
:
{ before(grammarAccess.getXLiteralRule()); }
	 ruleXLiteral
{ after(grammarAccess.getXLiteralRule()); } 
	 EOF 
;

// Rule XLiteral
ruleXLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXLiteralAccess().getAlternatives()); }
(rule__XLiteral__Alternatives)
{ after(grammarAccess.getXLiteralAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXCollectionLiteral
entryRuleXCollectionLiteral 
:
{ before(grammarAccess.getXCollectionLiteralRule()); }
	 ruleXCollectionLiteral
{ after(grammarAccess.getXCollectionLiteralRule()); } 
	 EOF 
;

// Rule XCollectionLiteral
ruleXCollectionLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
(rule__XCollectionLiteral__Alternatives)
{ after(grammarAccess.getXCollectionLiteralAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXSetLiteral
entryRuleXSetLiteral 
:
{ before(grammarAccess.getXSetLiteralRule()); }
	 ruleXSetLiteral
{ after(grammarAccess.getXSetLiteralRule()); } 
	 EOF 
;

// Rule XSetLiteral
ruleXSetLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXSetLiteralAccess().getGroup()); }
(rule__XSetLiteral__Group__0)
{ after(grammarAccess.getXSetLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXListLiteral
entryRuleXListLiteral 
:
{ before(grammarAccess.getXListLiteralRule()); }
	 ruleXListLiteral
{ after(grammarAccess.getXListLiteralRule()); } 
	 EOF 
;

// Rule XListLiteral
ruleXListLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXListLiteralAccess().getGroup()); }
(rule__XListLiteral__Group__0)
{ after(grammarAccess.getXListLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXClosure
entryRuleXClosure 
:
{ before(grammarAccess.getXClosureRule()); }
	 ruleXClosure
{ after(grammarAccess.getXClosureRule()); } 
	 EOF 
;

// Rule XClosure
ruleXClosure
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXClosureAccess().getGroup()); }
(rule__XClosure__Group__0)
{ after(grammarAccess.getXClosureAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXExpressionInClosure
entryRuleXExpressionInClosure 
:
{ before(grammarAccess.getXExpressionInClosureRule()); }
	 ruleXExpressionInClosure
{ after(grammarAccess.getXExpressionInClosureRule()); } 
	 EOF 
;

// Rule XExpressionInClosure
ruleXExpressionInClosure
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
(rule__XExpressionInClosure__Group__0)
{ after(grammarAccess.getXExpressionInClosureAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXShortClosure
entryRuleXShortClosure 
:
{ before(grammarAccess.getXShortClosureRule()); }
	 ruleXShortClosure
{ after(grammarAccess.getXShortClosureRule()); } 
	 EOF 
;

// Rule XShortClosure
ruleXShortClosure
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXShortClosureAccess().getGroup()); }
(rule__XShortClosure__Group__0)
{ after(grammarAccess.getXShortClosureAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXParenthesizedExpression
entryRuleXParenthesizedExpression 
:
{ before(grammarAccess.getXParenthesizedExpressionRule()); }
	 ruleXParenthesizedExpression
{ after(grammarAccess.getXParenthesizedExpressionRule()); } 
	 EOF 
;

// Rule XParenthesizedExpression
ruleXParenthesizedExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
(rule__XParenthesizedExpression__Group__0)
{ after(grammarAccess.getXParenthesizedExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXIfExpression
entryRuleXIfExpression 
:
{ before(grammarAccess.getXIfExpressionRule()); }
	 ruleXIfExpression
{ after(grammarAccess.getXIfExpressionRule()); } 
	 EOF 
;

// Rule XIfExpression
ruleXIfExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXIfExpressionAccess().getGroup()); }
(rule__XIfExpression__Group__0)
{ after(grammarAccess.getXIfExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXSwitchExpression
entryRuleXSwitchExpression 
:
{ before(grammarAccess.getXSwitchExpressionRule()); }
	 ruleXSwitchExpression
{ after(grammarAccess.getXSwitchExpressionRule()); } 
	 EOF 
;

// Rule XSwitchExpression
ruleXSwitchExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
(rule__XSwitchExpression__Group__0)
{ after(grammarAccess.getXSwitchExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXCasePart
entryRuleXCasePart 
:
{ before(grammarAccess.getXCasePartRule()); }
	 ruleXCasePart
{ after(grammarAccess.getXCasePartRule()); } 
	 EOF 
;

// Rule XCasePart
ruleXCasePart
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXCasePartAccess().getGroup()); }
(rule__XCasePart__Group__0)
{ after(grammarAccess.getXCasePartAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXForLoopExpression
entryRuleXForLoopExpression 
:
{ before(grammarAccess.getXForLoopExpressionRule()); }
	 ruleXForLoopExpression
{ after(grammarAccess.getXForLoopExpressionRule()); } 
	 EOF 
;

// Rule XForLoopExpression
ruleXForLoopExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
(rule__XForLoopExpression__Group__0)
{ after(grammarAccess.getXForLoopExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXBasicForLoopExpression
entryRuleXBasicForLoopExpression 
:
{ before(grammarAccess.getXBasicForLoopExpressionRule()); }
	 ruleXBasicForLoopExpression
{ after(grammarAccess.getXBasicForLoopExpressionRule()); } 
	 EOF 
;

// Rule XBasicForLoopExpression
ruleXBasicForLoopExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
(rule__XBasicForLoopExpression__Group__0)
{ after(grammarAccess.getXBasicForLoopExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXWhileExpression
entryRuleXWhileExpression 
:
{ before(grammarAccess.getXWhileExpressionRule()); }
	 ruleXWhileExpression
{ after(grammarAccess.getXWhileExpressionRule()); } 
	 EOF 
;

// Rule XWhileExpression
ruleXWhileExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXWhileExpressionAccess().getGroup()); }
(rule__XWhileExpression__Group__0)
{ after(grammarAccess.getXWhileExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXDoWhileExpression
entryRuleXDoWhileExpression 
:
{ before(grammarAccess.getXDoWhileExpressionRule()); }
	 ruleXDoWhileExpression
{ after(grammarAccess.getXDoWhileExpressionRule()); } 
	 EOF 
;

// Rule XDoWhileExpression
ruleXDoWhileExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
(rule__XDoWhileExpression__Group__0)
{ after(grammarAccess.getXDoWhileExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXBlockExpression
entryRuleXBlockExpression 
:
{ before(grammarAccess.getXBlockExpressionRule()); }
	 ruleXBlockExpression
{ after(grammarAccess.getXBlockExpressionRule()); } 
	 EOF 
;

// Rule XBlockExpression
ruleXBlockExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXBlockExpressionAccess().getGroup()); }
(rule__XBlockExpression__Group__0)
{ after(grammarAccess.getXBlockExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXExpressionOrVarDeclaration
entryRuleXExpressionOrVarDeclaration 
:
{ before(grammarAccess.getXExpressionOrVarDeclarationRule()); }
	 ruleXExpressionOrVarDeclaration
{ after(grammarAccess.getXExpressionOrVarDeclarationRule()); } 
	 EOF 
;

// Rule XExpressionOrVarDeclaration
ruleXExpressionOrVarDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
(rule__XExpressionOrVarDeclaration__Alternatives)
{ after(grammarAccess.getXExpressionOrVarDeclarationAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXVariableDeclaration
entryRuleXVariableDeclaration 
:
{ before(grammarAccess.getXVariableDeclarationRule()); }
	 ruleXVariableDeclaration
{ after(grammarAccess.getXVariableDeclarationRule()); } 
	 EOF 
;

// Rule XVariableDeclaration
ruleXVariableDeclaration
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
(rule__XVariableDeclaration__Group__0)
{ after(grammarAccess.getXVariableDeclarationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleJvmFormalParameter
entryRuleJvmFormalParameter 
:
{ before(grammarAccess.getJvmFormalParameterRule()); }
	 ruleJvmFormalParameter
{ after(grammarAccess.getJvmFormalParameterRule()); } 
	 EOF 
;

// Rule JvmFormalParameter
ruleJvmFormalParameter
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
(rule__JvmFormalParameter__Group__0)
{ after(grammarAccess.getJvmFormalParameterAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleFullJvmFormalParameter
entryRuleFullJvmFormalParameter 
:
{ before(grammarAccess.getFullJvmFormalParameterRule()); }
	 ruleFullJvmFormalParameter
{ after(grammarAccess.getFullJvmFormalParameterRule()); } 
	 EOF 
;

// Rule FullJvmFormalParameter
ruleFullJvmFormalParameter
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
(rule__FullJvmFormalParameter__Group__0)
{ after(grammarAccess.getFullJvmFormalParameterAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXFeatureCall
entryRuleXFeatureCall 
:
{ before(grammarAccess.getXFeatureCallRule()); }
	 ruleXFeatureCall
{ after(grammarAccess.getXFeatureCallRule()); } 
	 EOF 
;

// Rule XFeatureCall
ruleXFeatureCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXFeatureCallAccess().getGroup()); }
(rule__XFeatureCall__Group__0)
{ after(grammarAccess.getXFeatureCallAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleFeatureCallID
entryRuleFeatureCallID 
:
{ before(grammarAccess.getFeatureCallIDRule()); }
	 ruleFeatureCallID
{ after(grammarAccess.getFeatureCallIDRule()); } 
	 EOF 
;

// Rule FeatureCallID
ruleFeatureCallID
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
(rule__FeatureCallID__Alternatives)
{ after(grammarAccess.getFeatureCallIDAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIdOrSuper
entryRuleIdOrSuper 
:
{ before(grammarAccess.getIdOrSuperRule()); }
	 ruleIdOrSuper
{ after(grammarAccess.getIdOrSuperRule()); } 
	 EOF 
;

// Rule IdOrSuper
ruleIdOrSuper
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
(rule__IdOrSuper__Alternatives)
{ after(grammarAccess.getIdOrSuperAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXConstructorCall
entryRuleXConstructorCall 
:
{ before(grammarAccess.getXConstructorCallRule()); }
	 ruleXConstructorCall
{ after(grammarAccess.getXConstructorCallRule()); } 
	 EOF 
;

// Rule XConstructorCall
ruleXConstructorCall
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXConstructorCallAccess().getGroup()); }
(rule__XConstructorCall__Group__0)
{ after(grammarAccess.getXConstructorCallAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXBooleanLiteral
entryRuleXBooleanLiteral 
:
{ before(grammarAccess.getXBooleanLiteralRule()); }
	 ruleXBooleanLiteral
{ after(grammarAccess.getXBooleanLiteralRule()); } 
	 EOF 
;

// Rule XBooleanLiteral
ruleXBooleanLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
(rule__XBooleanLiteral__Group__0)
{ after(grammarAccess.getXBooleanLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXNullLiteral
entryRuleXNullLiteral 
:
{ before(grammarAccess.getXNullLiteralRule()); }
	 ruleXNullLiteral
{ after(grammarAccess.getXNullLiteralRule()); } 
	 EOF 
;

// Rule XNullLiteral
ruleXNullLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXNullLiteralAccess().getGroup()); }
(rule__XNullLiteral__Group__0)
{ after(grammarAccess.getXNullLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXNumberLiteral
entryRuleXNumberLiteral 
:
{ before(grammarAccess.getXNumberLiteralRule()); }
	 ruleXNumberLiteral
{ after(grammarAccess.getXNumberLiteralRule()); } 
	 EOF 
;

// Rule XNumberLiteral
ruleXNumberLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXNumberLiteralAccess().getGroup()); }
(rule__XNumberLiteral__Group__0)
{ after(grammarAccess.getXNumberLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXStringLiteral
entryRuleXStringLiteral 
:
{ before(grammarAccess.getXStringLiteralRule()); }
	 ruleXStringLiteral
{ after(grammarAccess.getXStringLiteralRule()); } 
	 EOF 
;

// Rule XStringLiteral
ruleXStringLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXStringLiteralAccess().getGroup()); }
(rule__XStringLiteral__Group__0)
{ after(grammarAccess.getXStringLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXTypeLiteral
entryRuleXTypeLiteral 
:
{ before(grammarAccess.getXTypeLiteralRule()); }
	 ruleXTypeLiteral
{ after(grammarAccess.getXTypeLiteralRule()); } 
	 EOF 
;

// Rule XTypeLiteral
ruleXTypeLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXTypeLiteralAccess().getGroup()); }
(rule__XTypeLiteral__Group__0)
{ after(grammarAccess.getXTypeLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXThrowExpression
entryRuleXThrowExpression 
:
{ before(grammarAccess.getXThrowExpressionRule()); }
	 ruleXThrowExpression
{ after(grammarAccess.getXThrowExpressionRule()); } 
	 EOF 
;

// Rule XThrowExpression
ruleXThrowExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXThrowExpressionAccess().getGroup()); }
(rule__XThrowExpression__Group__0)
{ after(grammarAccess.getXThrowExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXReturnExpression
entryRuleXReturnExpression 
:
{ before(grammarAccess.getXReturnExpressionRule()); }
	 ruleXReturnExpression
{ after(grammarAccess.getXReturnExpressionRule()); } 
	 EOF 
;

// Rule XReturnExpression
ruleXReturnExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXReturnExpressionAccess().getGroup()); }
(rule__XReturnExpression__Group__0)
{ after(grammarAccess.getXReturnExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXTryCatchFinallyExpression
entryRuleXTryCatchFinallyExpression 
:
{ before(grammarAccess.getXTryCatchFinallyExpressionRule()); }
	 ruleXTryCatchFinallyExpression
{ after(grammarAccess.getXTryCatchFinallyExpressionRule()); } 
	 EOF 
;

// Rule XTryCatchFinallyExpression
ruleXTryCatchFinallyExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
(rule__XTryCatchFinallyExpression__Group__0)
{ after(grammarAccess.getXTryCatchFinallyExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXSynchronizedExpression
entryRuleXSynchronizedExpression 
:
{ before(grammarAccess.getXSynchronizedExpressionRule()); }
	 ruleXSynchronizedExpression
{ after(grammarAccess.getXSynchronizedExpressionRule()); } 
	 EOF 
;

// Rule XSynchronizedExpression
ruleXSynchronizedExpression
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
(rule__XSynchronizedExpression__Group__0)
{ after(grammarAccess.getXSynchronizedExpressionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXCatchClause
entryRuleXCatchClause 
:
{ before(grammarAccess.getXCatchClauseRule()); }
	 ruleXCatchClause
{ after(grammarAccess.getXCatchClauseRule()); } 
	 EOF 
;

// Rule XCatchClause
ruleXCatchClause
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXCatchClauseAccess().getGroup()); }
(rule__XCatchClause__Group__0)
{ after(grammarAccess.getXCatchClauseAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleQualifiedName
entryRuleQualifiedName 
:
{ before(grammarAccess.getQualifiedNameRule()); }
	 ruleQualifiedName
{ after(grammarAccess.getQualifiedNameRule()); } 
	 EOF 
;

// Rule QualifiedName
ruleQualifiedName
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getQualifiedNameAccess().getGroup()); }
(rule__QualifiedName__Group__0)
{ after(grammarAccess.getQualifiedNameAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleNumber
entryRuleNumber 
@init {
	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
}
:
{ before(grammarAccess.getNumberRule()); }
	 ruleNumber
{ after(grammarAccess.getNumberRule()); } 
	 EOF 
;
finally {
	myHiddenTokenState.restore();
}

// Rule Number
ruleNumber
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getNumberAccess().getAlternatives()); }
(rule__Number__Alternatives)
{ after(grammarAccess.getNumberAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
	myHiddenTokenState.restore();
}





// Entry rule entryRuleJvmTypeReference
entryRuleJvmTypeReference 
:
{ before(grammarAccess.getJvmTypeReferenceRule()); }
	 ruleJvmTypeReference
{ after(grammarAccess.getJvmTypeReferenceRule()); } 
	 EOF 
;

// Rule JvmTypeReference
ruleJvmTypeReference
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
(rule__JvmTypeReference__Alternatives)
{ after(grammarAccess.getJvmTypeReferenceAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleArrayBrackets
entryRuleArrayBrackets 
:
{ before(grammarAccess.getArrayBracketsRule()); }
	 ruleArrayBrackets
{ after(grammarAccess.getArrayBracketsRule()); } 
	 EOF 
;

// Rule ArrayBrackets
ruleArrayBrackets
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getArrayBracketsAccess().getGroup()); }
(rule__ArrayBrackets__Group__0)
{ after(grammarAccess.getArrayBracketsAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleXFunctionTypeRef
entryRuleXFunctionTypeRef 
:
{ before(grammarAccess.getXFunctionTypeRefRule()); }
	 ruleXFunctionTypeRef
{ after(grammarAccess.getXFunctionTypeRefRule()); } 
	 EOF 
;

// Rule XFunctionTypeRef
ruleXFunctionTypeRef
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
(rule__XFunctionTypeRef__Group__0)
{ after(grammarAccess.getXFunctionTypeRefAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleJvmParameterizedTypeReference
entryRuleJvmParameterizedTypeReference 
:
{ before(grammarAccess.getJvmParameterizedTypeReferenceRule()); }
	 ruleJvmParameterizedTypeReference
{ after(grammarAccess.getJvmParameterizedTypeReferenceRule()); } 
	 EOF 
;

// Rule JvmParameterizedTypeReference
ruleJvmParameterizedTypeReference
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
(rule__JvmParameterizedTypeReference__Group__0)
{ after(grammarAccess.getJvmParameterizedTypeReferenceAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}



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

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

;
finally {
	restoreStackSize(stackSize);
}





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

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

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleValidID
entryRuleValidID 
:
{ before(grammarAccess.getValidIDRule()); }
	 ruleValidID
{ after(grammarAccess.getValidIDRule()); } 
	 EOF 
;

// Rule ValidID
ruleValidID
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
	RULE_ID
{ after(grammarAccess.getValidIDAccess().getIDTerminalRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule 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 UiDateFormat
ruleUiDateFormat
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiDateFormatAccess().getAlternatives()); }
(rule__UiDateFormat__Alternatives)
{ after(grammarAccess.getUiDateFormatAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule UiDateTimeResolution
ruleUiDateTimeResolution
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getAlternatives()); }
(rule__UiDateTimeResolution__Alternatives)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule UiSelectionType
ruleUiSelectionType
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiSelectionTypeAccess().getAlternatives()); }
(rule__UiSelectionType__Alternatives)
{ after(grammarAccess.getUiSelectionTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule UiAlignment
ruleUiAlignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiAlignmentAccess().getAlternatives()); }
(rule__UiAlignment__Alternatives)
{ after(grammarAccess.getUiAlignmentAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__UiRootElements__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiRootElementsAccess().getUiViewParserRuleCall_0()); }
	ruleUiView
{ after(grammarAccess.getUiRootElementsAccess().getUiViewParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiRootElementsAccess().getUiViewSetParserRuleCall_1()); }
	ruleUiViewSet
{ after(grammarAccess.getUiRootElementsAccess().getUiViewSetParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiRootElementsAccess().getUiValidatorAliasParserRuleCall_2()); }
	ruleUiValidatorAlias
{ after(grammarAccess.getUiRootElementsAccess().getUiValidatorAliasParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiRootElementsAccess().getUiMobileViewParserRuleCall_3()); }
	ruleUiMobileView
{ after(grammarAccess.getUiRootElementsAccess().getUiMobileViewParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Alternatives_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getValidatorDefAssignment_3_0()); }
(rule__UiValidatorAssignment__ValidatorDefAssignment_3_0)
{ after(grammarAccess.getUiValidatorAssignmentAccess().getValidatorDefAssignment_3_0()); }
)

    |(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getGroup_3_1()); }
(rule__UiValidatorAssignment__Group_3_1__0)
{ after(grammarAccess.getUiValidatorAssignmentAccess().getGroup_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getGroup_0()); }
(rule__UiBindingEndpointAssignment__Group_0__0)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getGroup_0()); }
)

    |(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getGroup_1()); }
(rule__UiBindingEndpointAssignment__Group_1__0)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getGroup_1()); }
)

    |(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getGroup_2()); }
(rule__UiBindingEndpointAssignment__Group_2__0)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiRawBindablePathSegment__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiRawBindablePathSegmentAccess().getFullStopKeyword_1_0()); }

	'.' 

{ after(grammarAccess.getUiRawBindablePathSegmentAccess().getFullStopKeyword_1_0()); }
)

    |(
{ before(grammarAccess.getUiRawBindablePathSegmentAccess().getToParentAssignment_1_1()); }
(rule__UiRawBindablePathSegment__ToParentAssignment_1_1)
{ after(grammarAccess.getUiRawBindablePathSegmentAccess().getToParentAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiCommand__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiCommandAccess().getUiMobileNavigationCommandParserRuleCall_0()); }
	ruleUiMobileNavigationCommand
{ after(grammarAccess.getUiCommandAccess().getUiMobileNavigationCommandParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiCommandAccess().getUiOpenDialogCommandParserRuleCall_1()); }
	ruleUiOpenDialogCommand
{ after(grammarAccess.getUiCommandAccess().getUiOpenDialogCommandParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiCommandAccess().getUiSearchWithDialogCommandParserRuleCall_2()); }
	ruleUiSearchWithDialogCommand
{ after(grammarAccess.getUiCommandAccess().getUiSearchWithDialogCommandParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiCommandAccess().getUiAddToTableCommandParserRuleCall_3()); }
	ruleUiAddToTableCommand
{ after(grammarAccess.getUiCommandAccess().getUiAddToTableCommandParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getUiCommandAccess().getUiRemoveFromTableCommandParserRuleCall_4()); }
	ruleUiRemoveFromTableCommand
{ after(grammarAccess.getUiCommandAccess().getUiRemoveFromTableCommandParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getUiCommandAccess().getUiSendEventCommandParserRuleCall_5()); }
	ruleUiSendEventCommand
{ after(grammarAccess.getUiCommandAccess().getUiSendEventCommandParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getUiCommandAccess().getUiSetNewInstanceCommandParserRuleCall_6()); }
	ruleUiSetNewInstanceCommand
{ after(grammarAccess.getUiCommandAccess().getUiSetNewInstanceCommandParserRuleCall_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiIDEView__Alternatives_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiIDEViewAccess().getBeanSlotsAssignment_4_0()); }
(rule__UiIDEView__BeanSlotsAssignment_4_0)
{ after(grammarAccess.getUiIDEViewAccess().getBeanSlotsAssignment_4_0()); }
)

    |(
{ before(grammarAccess.getUiIDEViewAccess().getBindingEndpointAliasAssignment_4_1()); }
(rule__UiIDEView__BindingEndpointAliasAssignment_4_1)
{ after(grammarAccess.getUiIDEViewAccess().getBindingEndpointAliasAssignment_4_1()); }
)

    |(
{ before(grammarAccess.getUiIDEViewAccess().getBindingsAssignment_4_2()); }
(rule__UiIDEView__BindingsAssignment_4_2)
{ after(grammarAccess.getUiIDEViewAccess().getBindingsAssignment_4_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiIDEView__Alternatives_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiIDEViewAccess().getBindingEndpointAliasAssignment_7_0()); }
(rule__UiIDEView__BindingEndpointAliasAssignment_7_0)
{ after(grammarAccess.getUiIDEViewAccess().getBindingEndpointAliasAssignment_7_0()); }
)

    |(
{ before(grammarAccess.getUiIDEViewAccess().getBindingsAssignment_7_1()); }
(rule__UiIDEView__BindingsAssignment_7_1)
{ after(grammarAccess.getUiIDEViewAccess().getBindingsAssignment_7_1()); }
)

    |(
{ before(grammarAccess.getUiIDEViewAccess().getValidatorAssignmentsAssignment_7_2()); }
(rule__UiIDEView__ValidatorAssignmentsAssignment_7_2)
{ after(grammarAccess.getUiIDEViewAccess().getValidatorAssignmentsAssignment_7_2()); }
)

    |(
{ before(grammarAccess.getUiIDEViewAccess().getProcessorAssignmentsAssignment_7_3()); }
(rule__UiIDEView__ProcessorAssignmentsAssignment_7_3)
{ after(grammarAccess.getUiIDEViewAccess().getProcessorAssignmentsAssignment_7_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiExposedAction__Alternatives_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiExposedActionAccess().getActionReferenceAssignment_3_0()); }
(rule__UiExposedAction__ActionReferenceAssignment_3_0)
{ after(grammarAccess.getUiExposedActionAccess().getActionReferenceAssignment_3_0()); }
)

    |(
{ before(grammarAccess.getUiExposedActionAccess().getActionIDAssignment_3_1()); }
(rule__UiExposedAction__ActionIDAssignment_3_1)
{ after(grammarAccess.getUiExposedActionAccess().getActionIDAssignment_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileNavBarAction__Alternatives_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileNavBarActionAccess().getActionReferenceAssignment_3_0()); }
(rule__UiMobileNavBarAction__ActionReferenceAssignment_3_0)
{ after(grammarAccess.getUiMobileNavBarActionAccess().getActionReferenceAssignment_3_0()); }
)

    |(
{ before(grammarAccess.getUiMobileNavBarActionAccess().getActionIDAssignment_3_1()); }
(rule__UiMobileNavBarAction__ActionIDAssignment_3_1)
{ after(grammarAccess.getUiMobileNavBarActionAccess().getActionIDAssignment_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileView__Alternatives_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileViewAccess().getBeanSlotsAssignment_4_0()); }
(rule__UiMobileView__BeanSlotsAssignment_4_0)
{ after(grammarAccess.getUiMobileViewAccess().getBeanSlotsAssignment_4_0()); }
)

    |(
{ before(grammarAccess.getUiMobileViewAccess().getBindingEndpointAliasAssignment_4_1()); }
(rule__UiMobileView__BindingEndpointAliasAssignment_4_1)
{ after(grammarAccess.getUiMobileViewAccess().getBindingEndpointAliasAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileView__Alternatives_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileViewAccess().getBindingEndpointAliasAssignment_7_0()); }
(rule__UiMobileView__BindingEndpointAliasAssignment_7_0)
{ after(grammarAccess.getUiMobileViewAccess().getBindingEndpointAliasAssignment_7_0()); }
)

    |(
{ before(grammarAccess.getUiMobileViewAccess().getBindingsAssignment_7_1()); }
(rule__UiMobileView__BindingsAssignment_7_1)
{ after(grammarAccess.getUiMobileViewAccess().getBindingsAssignment_7_1()); }
)

    |(
{ before(grammarAccess.getUiMobileViewAccess().getValidatorAssignmentsAssignment_7_2()); }
(rule__UiMobileView__ValidatorAssignmentsAssignment_7_2)
{ after(grammarAccess.getUiMobileViewAccess().getValidatorAssignmentsAssignment_7_2()); }
)

    |(
{ before(grammarAccess.getUiMobileViewAccess().getProcessorAssignmentsAssignment_7_3()); }
(rule__UiMobileView__ProcessorAssignmentsAssignment_7_3)
{ after(grammarAccess.getUiMobileViewAccess().getProcessorAssignmentsAssignment_7_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiTextField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiTextFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiTextField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiTextFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiTextFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiTextField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiTextFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiPasswordField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiPasswordFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiPasswordField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiPasswordFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiPasswordFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiPasswordField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiPasswordFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMaskedTextField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMaskedTextFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiMaskedTextField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiMaskedTextFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiMaskedTextFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiMaskedTextField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiMaskedTextFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMaskedNumericField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMaskedNumericFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiMaskedNumericField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiMaskedNumericFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiMaskedNumericFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiMaskedNumericField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiMaskedNumericFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMaskedDecimalField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMaskedDecimalFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiMaskedDecimalField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiMaskedDecimalFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiMaskedDecimalFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiMaskedDecimalField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiMaskedDecimalFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiPrefixedMaskedTextField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiPrefixedMaskedTextFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiPrefixedMaskedTextField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiPrefixedMaskedTextFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiPrefixedMaskedTextFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiPrefixedMaskedTextField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiPrefixedMaskedTextFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiRichTextArea__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiRichTextAreaAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiRichTextArea__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiRichTextAreaAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiRichTextAreaAccess().getBindingsAssignment_4_1_1()); }
(rule__UiRichTextArea__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiRichTextAreaAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiSuggestTextField__Alternatives_4_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiSuggestTextFieldAccess().getValidatorsAssignment_4_2_0()); }
(rule__UiSuggestTextField__ValidatorsAssignment_4_2_0)
{ after(grammarAccess.getUiSuggestTextFieldAccess().getValidatorsAssignment_4_2_0()); }
)

    |(
{ before(grammarAccess.getUiSuggestTextFieldAccess().getBindingsAssignment_4_2_1()); }
(rule__UiSuggestTextField__BindingsAssignment_4_2_1)
{ after(grammarAccess.getUiSuggestTextFieldAccess().getBindingsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanReferenceField__Alternatives_4_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanReferenceFieldAccess().getValidatorsAssignment_4_2_0()); }
(rule__UiBeanReferenceField__ValidatorsAssignment_4_2_0)
{ after(grammarAccess.getUiBeanReferenceFieldAccess().getValidatorsAssignment_4_2_0()); }
)

    |(
{ before(grammarAccess.getUiBeanReferenceFieldAccess().getBindingsAssignment_4_2_1()); }
(rule__UiBeanReferenceField__BindingsAssignment_4_2_1)
{ after(grammarAccess.getUiBeanReferenceFieldAccess().getBindingsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiTextArea__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiTextAreaAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiTextArea__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiTextAreaAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiTextAreaAccess().getBindingsAssignment_4_1_1()); }
(rule__UiTextArea__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiTextAreaAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiDateField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiDateFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiDateField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiDateFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiDateFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiDateField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiDateFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiBrowser__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBrowserAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiBrowser__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiBrowserAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiBrowserAccess().getBindingsAssignment_4_1_1()); }
(rule__UiBrowser__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiBrowserAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiProgressBar__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiProgressBarAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiProgressBar__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiProgressBarAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiProgressBarAccess().getBindingsAssignment_4_1_1()); }
(rule__UiProgressBar__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiProgressBarAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiTable__Alternatives_4_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiTableAccess().getValidatorsAssignment_4_4_0()); }
(rule__UiTable__ValidatorsAssignment_4_4_0)
{ after(grammarAccess.getUiTableAccess().getValidatorsAssignment_4_4_0()); }
)

    |(
{ before(grammarAccess.getUiTableAccess().getBindingsAssignment_4_4_1()); }
(rule__UiTable__BindingsAssignment_4_4_1)
{ after(grammarAccess.getUiTableAccess().getBindingsAssignment_4_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiComboBox__Alternatives_4_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiComboBoxAccess().getValidatorsAssignment_4_2_0()); }
(rule__UiComboBox__ValidatorsAssignment_4_2_0)
{ after(grammarAccess.getUiComboBoxAccess().getValidatorsAssignment_4_2_0()); }
)

    |(
{ before(grammarAccess.getUiComboBoxAccess().getBindingsAssignment_4_2_1()); }
(rule__UiComboBox__BindingsAssignment_4_2_1)
{ after(grammarAccess.getUiComboBoxAccess().getBindingsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileNavigationButton__Alternatives_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileNavigationButtonAccess().getTargetPageAssignment_4_0()); }
(rule__UiMobileNavigationButton__TargetPageAssignment_4_0)
{ after(grammarAccess.getUiMobileNavigationButtonAccess().getTargetPageAssignment_4_0()); }
)

    |(
{ before(grammarAccess.getUiMobileNavigationButtonAccess().getGroup_4_1()); }
(rule__UiMobileNavigationButton__Group_4_1__0)
{ after(grammarAccess.getUiMobileNavigationButtonAccess().getGroup_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileSwitch__Alternatives_4_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileSwitchAccess().getValidatorsAssignment_4_2_0()); }
(rule__UiMobileSwitch__ValidatorsAssignment_4_2_0)
{ after(grammarAccess.getUiMobileSwitchAccess().getValidatorsAssignment_4_2_0()); }
)

    |(
{ before(grammarAccess.getUiMobileSwitchAccess().getBindingsAssignment_4_2_1()); }
(rule__UiMobileSwitch__BindingsAssignment_4_2_1)
{ after(grammarAccess.getUiMobileSwitchAccess().getBindingsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiDecimalField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiDecimalFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiDecimalField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiDecimalFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiDecimalFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiDecimalField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiDecimalFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiOptionsGroup__Alternatives_4_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiOptionsGroupAccess().getValidatorsAssignment_4_2_0()); }
(rule__UiOptionsGroup__ValidatorsAssignment_4_2_0)
{ after(grammarAccess.getUiOptionsGroupAccess().getValidatorsAssignment_4_2_0()); }
)

    |(
{ before(grammarAccess.getUiOptionsGroupAccess().getBindingsAssignment_4_2_1()); }
(rule__UiOptionsGroup__BindingsAssignment_4_2_1)
{ after(grammarAccess.getUiOptionsGroupAccess().getBindingsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiList__Alternatives_4_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiListAccess().getValidatorsAssignment_4_2_0()); }
(rule__UiList__ValidatorsAssignment_4_2_0)
{ after(grammarAccess.getUiListAccess().getValidatorsAssignment_4_2_0()); }
)

    |(
{ before(grammarAccess.getUiListAccess().getBindingsAssignment_4_2_1()); }
(rule__UiList__BindingsAssignment_4_2_1)
{ after(grammarAccess.getUiListAccess().getBindingsAssignment_4_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiSortOrder__Alternatives_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiSortOrderAccess().getDescKeyword_2_0()); }

	'desc' 

{ after(grammarAccess.getUiSortOrderAccess().getDescKeyword_2_0()); }
)

    |(
{ before(grammarAccess.getUiSortOrderAccess().getAscAssignment_2_1()); }
(rule__UiSortOrder__AscAssignment_2_1)
{ after(grammarAccess.getUiSortOrderAccess().getAscAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiEmbeddable__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiEmbeddableAccess().getUiLayoutParserRuleCall_0()); }
	ruleUiLayout
{ after(grammarAccess.getUiEmbeddableAccess().getUiLayoutParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiEmbeddableAccess().getUiFieldParserRuleCall_1()); }
	ruleUiField
{ after(grammarAccess.getUiEmbeddableAccess().getUiFieldParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiEmbeddableAccess().getUiActionParserRuleCall_2()); }
	ruleUiAction
{ after(grammarAccess.getUiEmbeddableAccess().getUiActionParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiEmbeddableAccess().getUiTabSheetParserRuleCall_3()); }
	ruleUiTabSheet
{ after(grammarAccess.getUiEmbeddableAccess().getUiTabSheetParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileEmbeddable__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileLayoutParserRuleCall_0()); }
	ruleUiMobileLayout
{ after(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileLayoutParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileFieldParserRuleCall_1()); }
	ruleUiMobileField
{ after(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileFieldParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileTabSheetParserRuleCall_2()); }
	ruleUiMobileTabSheet
{ after(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileTabSheetParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileActionParserRuleCall_3()); }
	ruleUiMobileAction
{ after(grammarAccess.getUiMobileEmbeddableAccess().getUiMobileActionParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileLayout__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileHorizontalButtonGroupParserRuleCall_0()); }
	ruleUiMobileHorizontalButtonGroup
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileHorizontalButtonGroupParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileVerticalComponentGroupParserRuleCall_1()); }
	ruleUiMobileVerticalComponentGroup
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileVerticalComponentGroupParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileNavigationPageParserRuleCall_2()); }
	ruleUiMobileNavigationPage
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileNavigationPageParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileHorizontalLayoutParserRuleCall_3()); }
	ruleUiMobileHorizontalLayout
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileHorizontalLayoutParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileVerticalLayoutParserRuleCall_4()); }
	ruleUiMobileVerticalLayout
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileVerticalLayoutParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileSearchPanelParserRuleCall_5()); }
	ruleUiMobileSearchPanel
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileSearchPanelParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getUiMobileLayoutAccess().getUiMobileNavigationRootParserRuleCall_6()); }
	ruleUiMobileNavigationRoot
{ after(grammarAccess.getUiMobileLayoutAccess().getUiMobileNavigationRootParserRuleCall_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileField__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileFieldAccess().getUiMobileSwitchParserRuleCall_0()); }
	ruleUiMobileSwitch
{ after(grammarAccess.getUiMobileFieldAccess().getUiMobileSwitchParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiTextFieldParserRuleCall_1()); }
	ruleUiTextField
{ after(grammarAccess.getUiMobileFieldAccess().getUiTextFieldParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiMaskedTextFieldParserRuleCall_2()); }
	ruleUiMaskedTextField
{ after(grammarAccess.getUiMobileFieldAccess().getUiMaskedTextFieldParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiMaskedNumericFieldParserRuleCall_3()); }
	ruleUiMaskedNumericField
{ after(grammarAccess.getUiMobileFieldAccess().getUiMaskedNumericFieldParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiMaskedDecimalFieldParserRuleCall_4()); }
	ruleUiMaskedDecimalField
{ after(grammarAccess.getUiMobileFieldAccess().getUiMaskedDecimalFieldParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiPrefixedMaskedTextFieldParserRuleCall_5()); }
	ruleUiPrefixedMaskedTextField
{ after(grammarAccess.getUiMobileFieldAccess().getUiPrefixedMaskedTextFieldParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiRichTextAreaParserRuleCall_6()); }
	ruleUiRichTextArea
{ after(grammarAccess.getUiMobileFieldAccess().getUiRichTextAreaParserRuleCall_6()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiPasswordFieldParserRuleCall_7()); }
	ruleUiPasswordField
{ after(grammarAccess.getUiMobileFieldAccess().getUiPasswordFieldParserRuleCall_7()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiSuggestTextFieldParserRuleCall_8()); }
	ruleUiSuggestTextField
{ after(grammarAccess.getUiMobileFieldAccess().getUiSuggestTextFieldParserRuleCall_8()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiNumericFieldParserRuleCall_9()); }
	ruleUiNumericField
{ after(grammarAccess.getUiMobileFieldAccess().getUiNumericFieldParserRuleCall_9()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiTableParserRuleCall_10()); }
	ruleUiTable
{ after(grammarAccess.getUiMobileFieldAccess().getUiTableParserRuleCall_10()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiComboBoxParserRuleCall_11()); }
	ruleUiComboBox
{ after(grammarAccess.getUiMobileFieldAccess().getUiComboBoxParserRuleCall_11()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiImageParserRuleCall_12()); }
	ruleUiImage
{ after(grammarAccess.getUiMobileFieldAccess().getUiImageParserRuleCall_12()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiSearchFieldParserRuleCall_13()); }
	ruleUiSearchField
{ after(grammarAccess.getUiMobileFieldAccess().getUiSearchFieldParserRuleCall_13()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiLabelParserRuleCall_14()); }
	ruleUiLabel
{ after(grammarAccess.getUiMobileFieldAccess().getUiLabelParserRuleCall_14()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiDecimalFieldParserRuleCall_15()); }
	ruleUiDecimalField
{ after(grammarAccess.getUiMobileFieldAccess().getUiDecimalFieldParserRuleCall_15()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiTextAreaParserRuleCall_16()); }
	ruleUiTextArea
{ after(grammarAccess.getUiMobileFieldAccess().getUiTextAreaParserRuleCall_16()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiDateFieldParserRuleCall_17()); }
	ruleUiDateField
{ after(grammarAccess.getUiMobileFieldAccess().getUiDateFieldParserRuleCall_17()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiBrowserParserRuleCall_18()); }
	ruleUiBrowser
{ after(grammarAccess.getUiMobileFieldAccess().getUiBrowserParserRuleCall_18()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiProgressBarParserRuleCall_19()); }
	ruleUiProgressBar
{ after(grammarAccess.getUiMobileFieldAccess().getUiProgressBarParserRuleCall_19()); }
)

    |(
{ before(grammarAccess.getUiMobileFieldAccess().getUiOptionsGroupParserRuleCall_20()); }
	ruleUiOptionsGroup
{ after(grammarAccess.getUiMobileFieldAccess().getUiOptionsGroupParserRuleCall_20()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiLayout__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiLayoutAccess().getUiGridLayoutParserRuleCall_0()); }
	ruleUiGridLayout
{ after(grammarAccess.getUiLayoutAccess().getUiGridLayoutParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiLayoutAccess().getUiFormLayoutParserRuleCall_1()); }
	ruleUiFormLayout
{ after(grammarAccess.getUiLayoutAccess().getUiFormLayoutParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiLayoutAccess().getUiHorizontalLayoutParserRuleCall_2()); }
	ruleUiHorizontalLayout
{ after(grammarAccess.getUiLayoutAccess().getUiHorizontalLayoutParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiLayoutAccess().getUiVerticalLayoutParserRuleCall_3()); }
	ruleUiVerticalLayout
{ after(grammarAccess.getUiLayoutAccess().getUiVerticalLayoutParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getUiLayoutAccess().getUiSplitpanelParserRuleCall_4()); }
	ruleUiSplitpanel
{ after(grammarAccess.getUiLayoutAccess().getUiSplitpanelParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getUiLayoutAccess().getUiPanelParserRuleCall_5()); }
	ruleUiPanel
{ after(grammarAccess.getUiLayoutAccess().getUiPanelParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getUiLayoutAccess().getUiSearchPanelParserRuleCall_6()); }
	ruleUiSearchPanel
{ after(grammarAccess.getUiLayoutAccess().getUiSearchPanelParserRuleCall_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiField__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiFieldAccess().getUiTextFieldParserRuleCall_0()); }
	ruleUiTextField
{ after(grammarAccess.getUiFieldAccess().getUiTextFieldParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiMaskedTextFieldParserRuleCall_1()); }
	ruleUiMaskedTextField
{ after(grammarAccess.getUiFieldAccess().getUiMaskedTextFieldParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiMaskedNumericFieldParserRuleCall_2()); }
	ruleUiMaskedNumericField
{ after(grammarAccess.getUiFieldAccess().getUiMaskedNumericFieldParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiMaskedDecimalFieldParserRuleCall_3()); }
	ruleUiMaskedDecimalField
{ after(grammarAccess.getUiFieldAccess().getUiMaskedDecimalFieldParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiPrefixedMaskedTextFieldParserRuleCall_4()); }
	ruleUiPrefixedMaskedTextField
{ after(grammarAccess.getUiFieldAccess().getUiPrefixedMaskedTextFieldParserRuleCall_4()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiRichTextAreaParserRuleCall_5()); }
	ruleUiRichTextArea
{ after(grammarAccess.getUiFieldAccess().getUiRichTextAreaParserRuleCall_5()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiPasswordFieldParserRuleCall_6()); }
	ruleUiPasswordField
{ after(grammarAccess.getUiFieldAccess().getUiPasswordFieldParserRuleCall_6()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiSuggestTextFieldParserRuleCall_7()); }
	ruleUiSuggestTextField
{ after(grammarAccess.getUiFieldAccess().getUiSuggestTextFieldParserRuleCall_7()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiListParserRuleCall_8()); }
	ruleUiList
{ after(grammarAccess.getUiFieldAccess().getUiListParserRuleCall_8()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiNumericFieldParserRuleCall_9()); }
	ruleUiNumericField
{ after(grammarAccess.getUiFieldAccess().getUiNumericFieldParserRuleCall_9()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiCheckBoxParserRuleCall_10()); }
	ruleUiCheckBox
{ after(grammarAccess.getUiFieldAccess().getUiCheckBoxParserRuleCall_10()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiTableParserRuleCall_11()); }
	ruleUiTable
{ after(grammarAccess.getUiFieldAccess().getUiTableParserRuleCall_11()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiComboBoxParserRuleCall_12()); }
	ruleUiComboBox
{ after(grammarAccess.getUiFieldAccess().getUiComboBoxParserRuleCall_12()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiImageParserRuleCall_13()); }
	ruleUiImage
{ after(grammarAccess.getUiFieldAccess().getUiImageParserRuleCall_13()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiSearchFieldParserRuleCall_14()); }
	ruleUiSearchField
{ after(grammarAccess.getUiFieldAccess().getUiSearchFieldParserRuleCall_14()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiLabelParserRuleCall_15()); }
	ruleUiLabel
{ after(grammarAccess.getUiFieldAccess().getUiLabelParserRuleCall_15()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiDecimalFieldParserRuleCall_16()); }
	ruleUiDecimalField
{ after(grammarAccess.getUiFieldAccess().getUiDecimalFieldParserRuleCall_16()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiTextAreaParserRuleCall_17()); }
	ruleUiTextArea
{ after(grammarAccess.getUiFieldAccess().getUiTextAreaParserRuleCall_17()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiDateFieldParserRuleCall_18()); }
	ruleUiDateField
{ after(grammarAccess.getUiFieldAccess().getUiDateFieldParserRuleCall_18()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiBrowserParserRuleCall_19()); }
	ruleUiBrowser
{ after(grammarAccess.getUiFieldAccess().getUiBrowserParserRuleCall_19()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiProgressBarParserRuleCall_20()); }
	ruleUiProgressBar
{ after(grammarAccess.getUiFieldAccess().getUiProgressBarParserRuleCall_20()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiOptionsGroupParserRuleCall_21()); }
	ruleUiOptionsGroup
{ after(grammarAccess.getUiFieldAccess().getUiOptionsGroupParserRuleCall_21()); }
)

    |(
{ before(grammarAccess.getUiFieldAccess().getUiBeanReferenceFieldParserRuleCall_22()); }
	ruleUiBeanReferenceField
{ after(grammarAccess.getUiFieldAccess().getUiBeanReferenceFieldParserRuleCall_22()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiMobileAction__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiMobileActionAccess().getUiMobileNavigationButtonParserRuleCall_0()); }
	ruleUiMobileNavigationButton
{ after(grammarAccess.getUiMobileActionAccess().getUiMobileNavigationButtonParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiMobileActionAccess().getUiButtonParserRuleCall_1()); }
	ruleUiButton
{ after(grammarAccess.getUiMobileActionAccess().getUiButtonParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiNumericField__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiNumericFieldAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiNumericField__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiNumericFieldAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiNumericFieldAccess().getBindingsAssignment_4_1_1()); }
(rule__UiNumericField__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiNumericFieldAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiCheckBox__Alternatives_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiCheckBoxAccess().getValidatorsAssignment_4_1_0()); }
(rule__UiCheckBox__ValidatorsAssignment_4_1_0)
{ after(grammarAccess.getUiCheckBoxAccess().getValidatorsAssignment_4_1_0()); }
)

    |(
{ before(grammarAccess.getUiCheckBoxAccess().getBindingsAssignment_4_1_1()); }
(rule__UiCheckBox__BindingsAssignment_4_1_1)
{ after(grammarAccess.getUiCheckBoxAccess().getBindingsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidator__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAccess().getUiMaxLengthValidatorParserRuleCall_0()); }
	ruleUiMaxLengthValidator
{ after(grammarAccess.getUiValidatorAccess().getUiMaxLengthValidatorParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getUiValidatorAccess().getUiMinLengthValidatorParserRuleCall_1()); }
	ruleUiMinLengthValidator
{ after(grammarAccess.getUiValidatorAccess().getUiMinLengthValidatorParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getUiValidatorAccess().getUiRegexpValidatorParserRuleCall_2()); }
	ruleUiRegexpValidator
{ after(grammarAccess.getUiValidatorAccess().getUiRegexpValidatorParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getUiValidatorAccess().getUiXbaseValidatorParserRuleCall_3()); }
	ruleUiXbaseValidator
{ after(grammarAccess.getUiValidatorAccess().getUiXbaseValidatorParserRuleCall_3()); }
)

    |(
{ before(grammarAccess.getUiValidatorAccess().getUiBeanValidationValidatorParserRuleCall_4()); }
	ruleUiBeanValidationValidator
{ after(grammarAccess.getUiValidatorAccess().getUiBeanValidationValidatorParserRuleCall_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiVisibilityProcessor__Alternatives_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiVisibilityProcessorAccess().getDataUsedAssignment_4_0()); }
(rule__UiVisibilityProcessor__DataUsedAssignment_4_0)
{ after(grammarAccess.getUiVisibilityProcessorAccess().getDataUsedAssignment_4_0()); }
)

    |(
{ before(grammarAccess.getUiVisibilityProcessorAccess().getChangeTriggersAssignment_4_1()); }
(rule__UiVisibilityProcessor__ChangeTriggersAssignment_4_1)
{ after(grammarAccess.getUiVisibilityProcessorAccess().getChangeTriggersAssignment_4_1()); }
)

    |(
{ before(grammarAccess.getUiVisibilityProcessorAccess().getImportedElementsAssignment_4_2()); }
(rule__UiVisibilityProcessor__ImportedElementsAssignment_4_2)
{ after(grammarAccess.getUiVisibilityProcessorAccess().getImportedElementsAssignment_4_2()); }
)

;
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__UiDateFormat__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiDateFormatAccess().getDATEEnumLiteralDeclaration_0()); }
(	'date' 
)
{ after(grammarAccess.getUiDateFormatAccess().getDATEEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getUiDateFormatAccess().getDATE_TIMEEnumLiteralDeclaration_1()); }
(	'datetime' 
)
{ after(grammarAccess.getUiDateFormatAccess().getDATE_TIMEEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getUiDateFormatAccess().getTIMEEnumLiteralDeclaration_2()); }
(	'time' 
)
{ after(grammarAccess.getUiDateFormatAccess().getTIMEEnumLiteralDeclaration_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiDateTimeResolution__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getUNDEFINEDEnumLiteralDeclaration_0()); }
(	'undefined' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getUNDEFINEDEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getSECONDEnumLiteralDeclaration_1()); }
(	'second' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getSECONDEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getMINUTEEnumLiteralDeclaration_2()); }
(	'minute' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getMINUTEEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getHOUREnumLiteralDeclaration_3()); }
(	'hour' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getHOUREnumLiteralDeclaration_3()); }
)

    |(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getDAYEnumLiteralDeclaration_4()); }
(	'day' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getDAYEnumLiteralDeclaration_4()); }
)

    |(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getMONTHEnumLiteralDeclaration_5()); }
(	'month' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getMONTHEnumLiteralDeclaration_5()); }
)

    |(
{ before(grammarAccess.getUiDateTimeResolutionAccess().getYEAREnumLiteralDeclaration_6()); }
(	'year' 
)
{ after(grammarAccess.getUiDateTimeResolutionAccess().getYEAREnumLiteralDeclaration_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiSelectionType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiSelectionTypeAccess().getSINGLEEnumLiteralDeclaration_0()); }
(	'single' 
)
{ after(grammarAccess.getUiSelectionTypeAccess().getSINGLEEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getUiSelectionTypeAccess().getMULTIEnumLiteralDeclaration_1()); }
(	'multi' 
)
{ after(grammarAccess.getUiSelectionTypeAccess().getMULTIEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getUiSelectionTypeAccess().getNONEEnumLiteralDeclaration_2()); }
(	'none' 
)
{ after(grammarAccess.getUiSelectionTypeAccess().getNONEEnumLiteralDeclaration_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__UiAlignment__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiAlignmentAccess().getUNDEFINEDEnumLiteralDeclaration_0()); }
(	'undefined' 
)
{ after(grammarAccess.getUiAlignmentAccess().getUNDEFINEDEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getBOTTOM_CENTEREnumLiteralDeclaration_1()); }
(	'bottom-center' 
)
{ after(grammarAccess.getUiAlignmentAccess().getBOTTOM_CENTEREnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getBOTTOM_LEFTEnumLiteralDeclaration_2()); }
(	'bottom-left' 
)
{ after(grammarAccess.getUiAlignmentAccess().getBOTTOM_LEFTEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getBOTTOM_RIGHTEnumLiteralDeclaration_3()); }
(	'bottom-right' 
)
{ after(grammarAccess.getUiAlignmentAccess().getBOTTOM_RIGHTEnumLiteralDeclaration_3()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getBOTTOM_FILLEnumLiteralDeclaration_4()); }
(	'bottom-fill' 
)
{ after(grammarAccess.getUiAlignmentAccess().getBOTTOM_FILLEnumLiteralDeclaration_4()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getMIDDLE_CENTEREnumLiteralDeclaration_5()); }
(	'middle-center' 
)
{ after(grammarAccess.getUiAlignmentAccess().getMIDDLE_CENTEREnumLiteralDeclaration_5()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getMIDDLE_LEFTEnumLiteralDeclaration_6()); }
(	'middle-left' 
)
{ after(grammarAccess.getUiAlignmentAccess().getMIDDLE_LEFTEnumLiteralDeclaration_6()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getMIDDLE_RIGHTEnumLiteralDeclaration_7()); }
(	'middle-right' 
)
{ after(grammarAccess.getUiAlignmentAccess().getMIDDLE_RIGHTEnumLiteralDeclaration_7()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getMIDDLE_FILLEnumLiteralDeclaration_8()); }
(	'middle-fill' 
)
{ after(grammarAccess.getUiAlignmentAccess().getMIDDLE_FILLEnumLiteralDeclaration_8()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getTOP_CENTEREnumLiteralDeclaration_9()); }
(	'top-center' 
)
{ after(grammarAccess.getUiAlignmentAccess().getTOP_CENTEREnumLiteralDeclaration_9()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getTOP_LEFTEnumLiteralDeclaration_10()); }
(	'top-left' 
)
{ after(grammarAccess.getUiAlignmentAccess().getTOP_LEFTEnumLiteralDeclaration_10()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getTOP_RIGHTEnumLiteralDeclaration_11()); }
(	'top-right' 
)
{ after(grammarAccess.getUiAlignmentAccess().getTOP_RIGHTEnumLiteralDeclaration_11()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getTOP_FILLEnumLiteralDeclaration_12()); }
(	'top-fill' 
)
{ after(grammarAccess.getUiAlignmentAccess().getTOP_FILLEnumLiteralDeclaration_12()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getFILL_CENTEREnumLiteralDeclaration_13()); }
(	'fill-center' 
)
{ after(grammarAccess.getUiAlignmentAccess().getFILL_CENTEREnumLiteralDeclaration_13()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getFILL_LEFTEnumLiteralDeclaration_14()); }
(	'fill-left' 
)
{ after(grammarAccess.getUiAlignmentAccess().getFILL_LEFTEnumLiteralDeclaration_14()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getFILL_RIGHTEnumLiteralDeclaration_15()); }
(	'fill-right' 
)
{ after(grammarAccess.getUiAlignmentAccess().getFILL_RIGHTEnumLiteralDeclaration_15()); }
)

    |(
{ before(grammarAccess.getUiAlignmentAccess().getFILL_FILLEnumLiteralDeclaration_16()); }
(	'fill-fill' 
)
{ after(grammarAccess.getUiAlignmentAccess().getFILL_FILLEnumLiteralDeclaration_16()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__UiModel__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiModel__Group__0__Impl
	rule__UiModel__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiModel__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiModelAccess().getPackageKeyword_0()); }

	'package' 

{ after(grammarAccess.getUiModelAccess().getPackageKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiModel__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiModel__Group__1__Impl
	rule__UiModel__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiModel__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiModelAccess().getPackageNameAssignment_1()); }
(rule__UiModel__PackageNameAssignment_1)
{ after(grammarAccess.getUiModelAccess().getPackageNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiModel__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiModel__Group__2__Impl
	rule__UiModel__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiModel__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiModelAccess().getImportsAssignment_2()); }
(rule__UiModel__ImportsAssignment_2)*
{ after(grammarAccess.getUiModelAccess().getImportsAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiModel__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiModel__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiModel__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiModelAccess().getRootsAssignment_3()); }
(rule__UiModel__RootsAssignment_3)*
{ after(grammarAccess.getUiModelAccess().getRootsAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__UiImports__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiImports__Group__0__Impl
	rule__UiImports__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiImports__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiImportsAccess().getImportKeyword_0()); }

	'import' 

{ after(grammarAccess.getUiImportsAccess().getImportKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiImports__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiImports__Group__1__Impl
	rule__UiImports__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiImports__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiImportsAccess().getImportedNamespaceAssignment_1()); }
(rule__UiImports__ImportedNamespaceAssignment_1)
{ after(grammarAccess.getUiImportsAccess().getImportedNamespaceAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiImports__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiImports__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiImports__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiImportsAccess().getSemicolonKeyword_2()); }
(
	';' 
)?
{ after(grammarAccess.getUiImportsAccess().getSemicolonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__UiValidatorAlias__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAlias__Group__0__Impl
	rule__UiValidatorAlias__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAlias__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAliasAccess().getValidatorAliasKeyword_0()); }

	'validatorAlias' 

{ after(grammarAccess.getUiValidatorAliasAccess().getValidatorAliasKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAlias__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAlias__Group__1__Impl
	rule__UiValidatorAlias__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAlias__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAliasAccess().getValidatorAssignment_1()); }
(rule__UiValidatorAlias__ValidatorAssignment_1)
{ after(grammarAccess.getUiValidatorAliasAccess().getValidatorAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAlias__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAlias__Group__2__Impl
	rule__UiValidatorAlias__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAlias__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAliasAccess().getAsKeyword_2()); }

	'as' 

{ after(grammarAccess.getUiValidatorAliasAccess().getAsKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAlias__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAlias__Group__3__Impl
	rule__UiValidatorAlias__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAlias__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAliasAccess().getAliasAssignment_3()); }
(rule__UiValidatorAlias__AliasAssignment_3)
{ after(grammarAccess.getUiValidatorAliasAccess().getAliasAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAlias__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAlias__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAlias__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAliasAccess().getSemicolonKeyword_4()); }
(
	';' 
)?
{ after(grammarAccess.getUiValidatorAliasAccess().getSemicolonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__UiValidatorAssignment__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAssignment__Group__0__Impl
	rule__UiValidatorAssignment__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getFieldValidationKeyword_0()); }

	'fieldValidation' 

{ after(grammarAccess.getUiValidatorAssignmentAccess().getFieldValidationKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAssignment__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAssignment__Group__1__Impl
	rule__UiValidatorAssignment__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getFieldAssignment_1()); }
(rule__UiValidatorAssignment__FieldAssignment_1)
{ after(grammarAccess.getUiValidatorAssignmentAccess().getFieldAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAssignment__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAssignment__Group__2__Impl
	rule__UiValidatorAssignment__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getPlusSignEqualsSignKeyword_2()); }

	'+=' 

{ after(grammarAccess.getUiValidatorAssignmentAccess().getPlusSignEqualsSignKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAssignment__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAssignment__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getAlternatives_3()); }
(rule__UiValidatorAssignment__Alternatives_3)
{ after(grammarAccess.getUiValidatorAssignmentAccess().getAlternatives_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__UiValidatorAssignment__Group_3_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAssignment__Group_3_1__0__Impl
	rule__UiValidatorAssignment__Group_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Group_3_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getValidatorAliasAssignment_3_1_0()); }
(rule__UiValidatorAssignment__ValidatorAliasAssignment_3_1_0)
{ after(grammarAccess.getUiValidatorAssignmentAccess().getValidatorAliasAssignment_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiValidatorAssignment__Group_3_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiValidatorAssignment__Group_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiValidatorAssignment__Group_3_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiValidatorAssignmentAccess().getSemicolonKeyword_3_1_1()); }
(
	';' 
)?
{ after(grammarAccess.getUiValidatorAssignmentAccess().getSemicolonKeyword_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UiViewSet__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiViewSet__Group__0__Impl
	rule__UiViewSet__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiViewSet__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiViewSetAccess().getViewsetKeyword_0()); }

	'viewset' 

{ after(grammarAccess.getUiViewSetAccess().getViewsetKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiViewSet__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiViewSet__Group__1__Impl
	rule__UiViewSet__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiViewSet__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiViewSetAccess().getNameAssignment_1()); }
(rule__UiViewSet__NameAssignment_1)
{ after(grammarAccess.getUiViewSetAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiViewSet__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiViewSet__Group__2__Impl
	rule__UiViewSet__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiViewSet__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiViewSetAccess().getLeftCurlyBracketKeyword_2()); }

	'{' 

{ after(grammarAccess.getUiViewSetAccess().getLeftCurlyBracketKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiViewSet__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiViewSet__Group__3__Impl
	rule__UiViewSet__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UiViewSet__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiViewSetAccess().getBeanSlotsAssignment_3()); }
(rule__UiViewSet__BeanSlotsAssignment_3)*
{ after(grammarAccess.getUiViewSetAccess().getBeanSlotsAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiViewSet__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiViewSet__Group__4__Impl
	rule__UiViewSet__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__UiViewSet__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiViewSetAccess().getBindingEndpointAliasAssignment_4()); }
(rule__UiViewSet__BindingEndpointAliasAssignment_4)*
{ after(grammarAccess.getUiViewSetAccess().getBindingEndpointAliasAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiViewSet__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiViewSet__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiViewSet__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiViewSetAccess().getRightCurlyBracketKeyword_5()); }

	'}' 

{ after(grammarAccess.getUiViewSetAccess().getRightCurlyBracketKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__UiBindingEndpointAlias__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAlias__Group__0__Impl
	rule__UiBindingEndpointAlias__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAlias__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAliasAccess().getDataAliasKeyword_0()); }

	'dataAlias' 

{ after(grammarAccess.getUiBindingEndpointAliasAccess().getDataAliasKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAlias__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAlias__Group__1__Impl
	rule__UiBindingEndpointAlias__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAlias__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAliasAccess().getEndpointAssignment_1()); }
(rule__UiBindingEndpointAlias__EndpointAssignment_1)
{ after(grammarAccess.getUiBindingEndpointAliasAccess().getEndpointAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAlias__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAlias__Group__2__Impl
	rule__UiBindingEndpointAlias__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAlias__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAliasAccess().getAsKeyword_2()); }

	'as' 

{ after(grammarAccess.getUiBindingEndpointAliasAccess().getAsKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAlias__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAlias__Group__3__Impl
	rule__UiBindingEndpointAlias__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAlias__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAliasAccess().getAliasAssignment_3()); }
(rule__UiBindingEndpointAlias__AliasAssignment_3)
{ after(grammarAccess.getUiBindingEndpointAliasAccess().getAliasAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAlias__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAlias__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAlias__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAliasAccess().getSemicolonKeyword_4()); }
(
	';' 
)?
{ after(grammarAccess.getUiBindingEndpointAliasAccess().getSemicolonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__UiBeanSlot__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group__0__Impl
	rule__UiBeanSlot__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getDatasourceKeyword_0()); }

	'datasource' 

{ after(grammarAccess.getUiBeanSlotAccess().getDatasourceKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBeanSlot__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group__1__Impl
	rule__UiBeanSlot__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getNameAssignment_1()); }
(rule__UiBeanSlot__NameAssignment_1)
{ after(grammarAccess.getUiBeanSlotAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBeanSlot__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group__2__Impl
	rule__UiBeanSlot__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getColonKeyword_2()); }

	':' 

{ after(grammarAccess.getUiBeanSlotAccess().getColonKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBeanSlot__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group__3__Impl
	rule__UiBeanSlot__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getJvmTypeAssignment_3()); }
(rule__UiBeanSlot__JvmTypeAssignment_3)
{ after(grammarAccess.getUiBeanSlotAccess().getJvmTypeAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBeanSlot__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group__4__Impl
	rule__UiBeanSlot__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getGroup_4()); }
(rule__UiBeanSlot__Group_4__0)?
{ after(grammarAccess.getUiBeanSlotAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBeanSlot__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getSemicolonKeyword_5()); }
(
	';' 
)?
{ after(grammarAccess.getUiBeanSlotAccess().getSemicolonKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__UiBeanSlot__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group_4__0__Impl
	rule__UiBeanSlot__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getEventTopicKeyword_4_0()); }

	'eventTopic' 

{ after(grammarAccess.getUiBeanSlotAccess().getEventTopicKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBeanSlot__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBeanSlot__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBeanSlot__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBeanSlotAccess().getEventTopicAssignment_4_1()); }
(rule__UiBeanSlot__EventTopicAssignment_4_1)
{ after(grammarAccess.getUiBeanSlotAccess().getEventTopicAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UiBinding__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group__0__Impl
	rule__UiBinding__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getBindKeyword_0()); }

	'bind' 

{ after(grammarAccess.getUiBindingAccess().getBindKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group__1__Impl
	rule__UiBinding__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getListBindingAssignment_1()); }
(rule__UiBinding__ListBindingAssignment_1)?
{ after(grammarAccess.getUiBindingAccess().getListBindingAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group__2__Impl
	rule__UiBinding__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getSourceAssignment_2()); }
(rule__UiBinding__SourceAssignment_2)
{ after(grammarAccess.getUiBindingAccess().getSourceAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group__3__Impl
	rule__UiBinding__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getGroup_3()); }
(rule__UiBinding__Group_3__0)
{ after(grammarAccess.getUiBindingAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group__4__Impl
	rule__UiBinding__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getTargetAssignment_4()); }
(rule__UiBinding__TargetAssignment_4)
{ after(grammarAccess.getUiBindingAccess().getTargetAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getSemicolonKeyword_5()); }
(
	';' 
)?
{ after(grammarAccess.getUiBindingAccess().getSemicolonKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__UiBinding__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group_3__0__Impl
	rule__UiBinding__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getTargetToSourceAssignment_3_0()); }
(rule__UiBinding__TargetToSourceAssignment_3_0)?
{ after(grammarAccess.getUiBindingAccess().getTargetToSourceAssignment_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group_3__1__Impl
	rule__UiBinding__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getHyphenMinusHyphenMinusKeyword_3_1()); }

	'--' 

{ after(grammarAccess.getUiBindingAccess().getHyphenMinusHyphenMinusKeyword_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBinding__Group_3__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBinding__Group_3__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBinding__Group_3__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingAccess().getSourceToTargetAssignment_3_2()); }
(rule__UiBinding__SourceToTargetAssignment_3_2)?
{ after(grammarAccess.getUiBindingAccess().getSourceToTargetAssignment_3_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__UiBindingEndpointAssignment__Group_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_0__0__Impl
	rule__UiBindingEndpointAssignment__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiTypedBindableDefParserRuleCall_0_0()); }
	ruleUiTypedBindableDef
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiTypedBindableDefParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAssignment__Group_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_0__1__Impl
	rule__UiBindingEndpointAssignment__Group_0__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiBindingEndpointAssignmentTypedBindableDefAction_0_1()); }
(

)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiBindingEndpointAssignmentTypedBindableDefAction_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAssignment__Group_0__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_0__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_0__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getPathAssignment_0_2()); }
(rule__UiBindingEndpointAssignment__PathAssignment_0_2)?
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getPathAssignment_0_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__UiBindingEndpointAssignment__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_1__0__Impl
	rule__UiBindingEndpointAssignment__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiCommandBindableDefParserRuleCall_1_0()); }
	ruleUiCommandBindableDef
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiCommandBindableDefParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAssignment__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiBindingEndpointAssignmentTypedBindableDefAction_1_1()); }
(

)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiBindingEndpointAssignmentTypedBindableDefAction_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__UiBindingEndpointAssignment__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_2__0__Impl
	rule__UiBindingEndpointAssignment__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiBindingEndpointAssignmentAction_2_0()); }
(

)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getUiBindingEndpointAssignmentAction_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAssignment__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_2__1__Impl
	rule__UiBindingEndpointAssignment__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getUiBindingEndpointAssignmentAccess().getTypedBindableAliasAssignment_2_1()); }
(rule__UiBindingEndpointAssignment__TypedBindableAliasAssignment_2_1)
{ after(grammarAccess.getUiBindingEndpointAssignmentAccess().getTypedBindableAliasAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__UiBindingEndpointAssignment__Group_2__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__UiBindingEndpointAssignment__Group_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__UiBindingEndpointAssignment__Group_2__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(