plugins/org.eclipse.etrice.core.room.ui/src-gen/org/eclipse/etrice/core/ui/contentassist/antlr/internal/InternalRoom.g

/*
* generated by Xtext
*/
grammar InternalRoom;

options {
	superClass=AbstractInternalContentAssistParser;
	
}

@lexer::header {
package org.eclipse.etrice.core.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.etrice.core.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.etrice.core.services.RoomGrammarAccess;

}

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

}




// Entry rule entryRuleRoomModel
entryRuleRoomModel 
:
{ before(grammarAccess.getRoomModelRule()); }
	 ruleRoomModel
{ after(grammarAccess.getRoomModelRule()); } 
	 EOF 
;

// Rule RoomModel
ruleRoomModel
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRoomModelAccess().getGroup()); }
(rule__RoomModel__Group__0)
{ after(grammarAccess.getRoomModelAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleStructureClass
entryRuleStructureClass 
:
{ before(grammarAccess.getStructureClassRule()); }
	 ruleStructureClass
{ after(grammarAccess.getStructureClassRule()); } 
	 EOF 
;

// Rule StructureClass
ruleStructureClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStructureClassAccess().getAlternatives()); }
(rule__StructureClass__Alternatives)
{ after(grammarAccess.getStructureClassAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleActorContainerClass
entryRuleActorContainerClass 
:
{ before(grammarAccess.getActorContainerClassRule()); }
	 ruleActorContainerClass
{ after(grammarAccess.getActorContainerClassRule()); } 
	 EOF 
;

// Rule ActorContainerClass
ruleActorContainerClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getActorContainerClassAccess().getAlternatives()); }
(rule__ActorContainerClass__Alternatives)
{ after(grammarAccess.getActorContainerClassAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleVarDecl
entryRuleVarDecl 
:
{ before(grammarAccess.getVarDeclRule()); }
	 ruleVarDecl
{ after(grammarAccess.getVarDeclRule()); } 
	 EOF 
;

// Rule VarDecl
ruleVarDecl
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getVarDeclAccess().getGroup()); }
(rule__VarDecl__Group__0)
{ after(grammarAccess.getVarDeclAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRefableType
entryRuleRefableType 
:
{ before(grammarAccess.getRefableTypeRule()); }
	 ruleRefableType
{ after(grammarAccess.getRefableTypeRule()); } 
	 EOF 
;

// Rule RefableType
ruleRefableType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRefableTypeAccess().getGroup()); }
(rule__RefableType__Group__0)
{ after(grammarAccess.getRefableTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDataType
entryRuleDataType 
:
{ before(grammarAccess.getDataTypeRule()); }
	 ruleDataType
{ after(grammarAccess.getDataTypeRule()); } 
	 EOF 
;

// Rule DataType
ruleDataType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDataTypeAccess().getAlternatives()); }
(rule__DataType__Alternatives)
{ after(grammarAccess.getDataTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleComplexType
entryRuleComplexType 
:
{ before(grammarAccess.getComplexTypeRule()); }
	 ruleComplexType
{ after(grammarAccess.getComplexTypeRule()); } 
	 EOF 
;

// Rule ComplexType
ruleComplexType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getComplexTypeAccess().getAlternatives()); }
(rule__ComplexType__Alternatives)
{ after(grammarAccess.getComplexTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePrimitiveType
entryRulePrimitiveType 
:
{ before(grammarAccess.getPrimitiveTypeRule()); }
	 rulePrimitiveType
{ after(grammarAccess.getPrimitiveTypeRule()); } 
	 EOF 
;

// Rule PrimitiveType
rulePrimitiveType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getGroup()); }
(rule__PrimitiveType__Group__0)
{ after(grammarAccess.getPrimitiveTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEnumerationType
entryRuleEnumerationType 
:
{ before(grammarAccess.getEnumerationTypeRule()); }
	 ruleEnumerationType
{ after(grammarAccess.getEnumerationTypeRule()); } 
	 EOF 
;

// Rule EnumerationType
ruleEnumerationType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEnumerationTypeAccess().getGroup()); }
(rule__EnumerationType__Group__0)
{ after(grammarAccess.getEnumerationTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEnumLiteral
entryRuleEnumLiteral 
:
{ before(grammarAccess.getEnumLiteralRule()); }
	 ruleEnumLiteral
{ after(grammarAccess.getEnumLiteralRule()); } 
	 EOF 
;

// Rule EnumLiteral
ruleEnumLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEnumLiteralAccess().getGroup()); }
(rule__EnumLiteral__Group__0)
{ after(grammarAccess.getEnumLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleExternalType
entryRuleExternalType 
:
{ before(grammarAccess.getExternalTypeRule()); }
	 ruleExternalType
{ after(grammarAccess.getExternalTypeRule()); } 
	 EOF 
;

// Rule ExternalType
ruleExternalType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getExternalTypeAccess().getGroup()); }
(rule__ExternalType__Group__0)
{ after(grammarAccess.getExternalTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDataClass
entryRuleDataClass 
:
{ before(grammarAccess.getDataClassRule()); }
	 ruleDataClass
{ after(grammarAccess.getDataClassRule()); } 
	 EOF 
;

// Rule DataClass
ruleDataClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDataClassAccess().getGroup()); }
(rule__DataClass__Group__0)
{ after(grammarAccess.getDataClassAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAttribute
entryRuleAttribute 
:
{ before(grammarAccess.getAttributeRule()); }
	 ruleAttribute
{ after(grammarAccess.getAttributeRule()); } 
	 EOF 
;

// Rule Attribute
ruleAttribute
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAttributeAccess().getGroup()); }
(rule__Attribute__Group__0)
{ after(grammarAccess.getAttributeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleStandardOperation
entryRuleStandardOperation 
:
{ before(grammarAccess.getStandardOperationRule()); }
	 ruleStandardOperation
{ after(grammarAccess.getStandardOperationRule()); } 
	 EOF 
;

// Rule StandardOperation
ruleStandardOperation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStandardOperationAccess().getGroup()); }
(rule__StandardOperation__Group__0)
{ after(grammarAccess.getStandardOperationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePortOperation
entryRulePortOperation 
:
{ before(grammarAccess.getPortOperationRule()); }
	 rulePortOperation
{ after(grammarAccess.getPortOperationRule()); } 
	 EOF 
;

// Rule PortOperation
rulePortOperation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPortOperationAccess().getGroup()); }
(rule__PortOperation__Group__0)
{ after(grammarAccess.getPortOperationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleClassStructor
entryRuleClassStructor 
:
{ before(grammarAccess.getClassStructorRule()); }
	 ruleClassStructor
{ after(grammarAccess.getClassStructorRule()); } 
	 EOF 
;

// Rule ClassStructor
ruleClassStructor
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getClassStructorAccess().getGroup()); }
(rule__ClassStructor__Group__0)
{ after(grammarAccess.getClassStructorAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleGeneralProtocolClass
entryRuleGeneralProtocolClass 
:
{ before(grammarAccess.getGeneralProtocolClassRule()); }
	 ruleGeneralProtocolClass
{ after(grammarAccess.getGeneralProtocolClassRule()); } 
	 EOF 
;

// Rule GeneralProtocolClass
ruleGeneralProtocolClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getGeneralProtocolClassAccess().getAlternatives()); }
(rule__GeneralProtocolClass__Alternatives)
{ after(grammarAccess.getGeneralProtocolClassAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleProtocolClass
entryRuleProtocolClass 
:
{ before(grammarAccess.getProtocolClassRule()); }
	 ruleProtocolClass
{ after(grammarAccess.getProtocolClassRule()); } 
	 EOF 
;

// Rule ProtocolClass
ruleProtocolClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup()); }
(rule__ProtocolClass__Group__0)
{ after(grammarAccess.getProtocolClassAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleCompoundProtocolClass
entryRuleCompoundProtocolClass 
:
{ before(grammarAccess.getCompoundProtocolClassRule()); }
	 ruleCompoundProtocolClass
{ after(grammarAccess.getCompoundProtocolClassRule()); } 
	 EOF 
;

// Rule CompoundProtocolClass
ruleCompoundProtocolClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getGroup()); }
(rule__CompoundProtocolClass__Group__0)
{ after(grammarAccess.getCompoundProtocolClassAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSubProtocol
entryRuleSubProtocol 
:
{ before(grammarAccess.getSubProtocolRule()); }
	 ruleSubProtocol
{ after(grammarAccess.getSubProtocolRule()); } 
	 EOF 
;

// Rule SubProtocol
ruleSubProtocol
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSubProtocolAccess().getGroup()); }
(rule__SubProtocol__Group__0)
{ after(grammarAccess.getSubProtocolAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleMessage
entryRuleMessage 
:
{ before(grammarAccess.getMessageRule()); }
	 ruleMessage
{ after(grammarAccess.getMessageRule()); } 
	 EOF 
;

// Rule Message
ruleMessage
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getMessageAccess().getGroup()); }
(rule__Message__Group__0)
{ after(grammarAccess.getMessageAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePortClass
entryRulePortClass 
:
{ before(grammarAccess.getPortClassRule()); }
	 rulePortClass
{ after(grammarAccess.getPortClassRule()); } 
	 EOF 
;

// Rule PortClass
rulePortClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPortClassAccess().getGroup()); }
(rule__PortClass__Group__0)
{ after(grammarAccess.getPortClassAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleMessageHandler
entryRuleMessageHandler 
:
{ before(grammarAccess.getMessageHandlerRule()); }
	 ruleMessageHandler
{ after(grammarAccess.getMessageHandlerRule()); } 
	 EOF 
;

// Rule MessageHandler
ruleMessageHandler
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getMessageHandlerAccess().getAlternatives()); }
(rule__MessageHandler__Alternatives)
{ after(grammarAccess.getMessageHandlerAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleInMessageHandler
entryRuleInMessageHandler 
:
{ before(grammarAccess.getInMessageHandlerRule()); }
	 ruleInMessageHandler
{ after(grammarAccess.getInMessageHandlerRule()); } 
	 EOF 
;

// Rule InMessageHandler
ruleInMessageHandler
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getInMessageHandlerAccess().getGroup()); }
(rule__InMessageHandler__Group__0)
{ after(grammarAccess.getInMessageHandlerAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOutMessageHandler
entryRuleOutMessageHandler 
:
{ before(grammarAccess.getOutMessageHandlerRule()); }
	 ruleOutMessageHandler
{ after(grammarAccess.getOutMessageHandlerRule()); } 
	 EOF 
;

// Rule OutMessageHandler
ruleOutMessageHandler
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getGroup()); }
(rule__OutMessageHandler__Group__0)
{ after(grammarAccess.getOutMessageHandlerAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleModelComponent
entryRuleModelComponent 
:
{ before(grammarAccess.getModelComponentRule()); }
	 ruleModelComponent
{ after(grammarAccess.getModelComponentRule()); } 
	 EOF 
;

// Rule ModelComponent
ruleModelComponent
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getModelComponentAccess().getActorClassParserRuleCall()); }
	ruleActorClass
{ after(grammarAccess.getModelComponentAccess().getActorClassParserRuleCall()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleActorClass
entryRuleActorClass 
:
{ before(grammarAccess.getActorClassRule()); }
	 ruleActorClass
{ after(grammarAccess.getActorClassRule()); } 
	 EOF 
;

// Rule ActorClass
ruleActorClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getActorClassAccess().getGroup()); }
(rule__ActorClass__Group__0)
{ after(grammarAccess.getActorClassAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleInterfaceItem
entryRuleInterfaceItem 
:
{ before(grammarAccess.getInterfaceItemRule()); }
	 ruleInterfaceItem
{ after(grammarAccess.getInterfaceItemRule()); } 
	 EOF 
;

// Rule InterfaceItem
ruleInterfaceItem
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getInterfaceItemAccess().getAlternatives()); }
(rule__InterfaceItem__Alternatives)
{ after(grammarAccess.getInterfaceItemAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRulePort
entryRulePort 
:
{ before(grammarAccess.getPortRule()); }
	 rulePort
{ after(grammarAccess.getPortRule()); } 
	 EOF 
;

// Rule Port
rulePort
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getPortAccess().getGroup()); }
(rule__Port__Group__0)
{ after(grammarAccess.getPortAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleExternalPort
entryRuleExternalPort 
:
{ before(grammarAccess.getExternalPortRule()); }
	 ruleExternalPort
{ after(grammarAccess.getExternalPortRule()); } 
	 EOF 
;

// Rule ExternalPort
ruleExternalPort
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getExternalPortAccess().getGroup()); }
(rule__ExternalPort__Group__0)
{ after(grammarAccess.getExternalPortAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSAP
entryRuleSAP 
:
{ before(grammarAccess.getSAPRule()); }
	 ruleSAP
{ after(grammarAccess.getSAPRule()); } 
	 EOF 
;

// Rule SAP
ruleSAP
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSAPAccess().getGroup()); }
(rule__SAP__Group__0)
{ after(grammarAccess.getSAPAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSPP
entryRuleSPP 
:
{ before(grammarAccess.getSPPRule()); }
	 ruleSPP
{ after(grammarAccess.getSPPRule()); } 
	 EOF 
;

// Rule SPP
ruleSPP
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSPPAccess().getGroup()); }
(rule__SPP__Group__0)
{ after(grammarAccess.getSPPAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleServiceImplementation
entryRuleServiceImplementation 
:
{ before(grammarAccess.getServiceImplementationRule()); }
	 ruleServiceImplementation
{ after(grammarAccess.getServiceImplementationRule()); } 
	 EOF 
;

// Rule ServiceImplementation
ruleServiceImplementation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getServiceImplementationAccess().getGroup()); }
(rule__ServiceImplementation__Group__0)
{ after(grammarAccess.getServiceImplementationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLogicalSystem
entryRuleLogicalSystem 
:
{ before(grammarAccess.getLogicalSystemRule()); }
	 ruleLogicalSystem
{ after(grammarAccess.getLogicalSystemRule()); } 
	 EOF 
;

// Rule LogicalSystem
ruleLogicalSystem
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLogicalSystemAccess().getGroup()); }
(rule__LogicalSystem__Group__0)
{ after(grammarAccess.getLogicalSystemAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleSubSystemRef
entryRuleSubSystemRef 
:
{ before(grammarAccess.getSubSystemRefRule()); }
	 ruleSubSystemRef
{ after(grammarAccess.getSubSystemRefRule()); } 
	 EOF 
;

// Rule SubSystemRef
ruleSubSystemRef
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSubSystemRefAccess().getGroup()); }
(rule__SubSystemRef__Group__0)
{ after(grammarAccess.getSubSystemRefAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSubSystemClass
entryRuleSubSystemClass 
:
{ before(grammarAccess.getSubSystemClassRule()); }
	 ruleSubSystemClass
{ after(grammarAccess.getSubSystemClassRule()); } 
	 EOF 
;

// Rule SubSystemClass
ruleSubSystemClass
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSubSystemClassAccess().getGroup()); }
(rule__SubSystemClass__Group__0)
{ after(grammarAccess.getSubSystemClassAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLogicalThread
entryRuleLogicalThread 
:
{ before(grammarAccess.getLogicalThreadRule()); }
	 ruleLogicalThread
{ after(grammarAccess.getLogicalThreadRule()); } 
	 EOF 
;

// Rule LogicalThread
ruleLogicalThread
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLogicalThreadAccess().getGroup()); }
(rule__LogicalThread__Group__0)
{ after(grammarAccess.getLogicalThreadAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleActorInstanceMapping
entryRuleActorInstanceMapping 
:
{ before(grammarAccess.getActorInstanceMappingRule()); }
	 ruleActorInstanceMapping
{ after(grammarAccess.getActorInstanceMappingRule()); } 
	 EOF 
;

// Rule ActorInstanceMapping
ruleActorInstanceMapping
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getGroup()); }
(rule__ActorInstanceMapping__Group__0)
{ after(grammarAccess.getActorInstanceMappingAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRefPath
entryRuleRefPath 
:
{ before(grammarAccess.getRefPathRule()); }
	 ruleRefPath
{ after(grammarAccess.getRefPathRule()); } 
	 EOF 
;

// Rule RefPath
ruleRefPath
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRefPathAccess().getGroup()); }
(rule__RefPath__Group__0)
{ after(grammarAccess.getRefPathAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRefSegment
entryRuleRefSegment 
:
{ before(grammarAccess.getRefSegmentRule()); }
	 ruleRefSegment
{ after(grammarAccess.getRefSegmentRule()); } 
	 EOF 
;

// Rule RefSegment
ruleRefSegment
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRefSegmentAccess().getGroup()); }
(rule__RefSegment__Group__0)
{ after(grammarAccess.getRefSegmentAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleBinding
entryRuleBinding 
:
{ before(grammarAccess.getBindingRule()); }
	 ruleBinding
{ after(grammarAccess.getBindingRule()); } 
	 EOF 
;

// Rule Binding
ruleBinding
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getBindingAccess().getGroup()); }
(rule__Binding__Group__0)
{ after(grammarAccess.getBindingAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleBindingEndPoint
entryRuleBindingEndPoint 
:
{ before(grammarAccess.getBindingEndPointRule()); }
	 ruleBindingEndPoint
{ after(grammarAccess.getBindingEndPointRule()); } 
	 EOF 
;

// Rule BindingEndPoint
ruleBindingEndPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getBindingEndPointAccess().getGroup()); }
(rule__BindingEndPoint__Group__0)
{ after(grammarAccess.getBindingEndPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleLayerConnection
entryRuleLayerConnection 
:
{ before(grammarAccess.getLayerConnectionRule()); }
	 ruleLayerConnection
{ after(grammarAccess.getLayerConnectionRule()); } 
	 EOF 
;

// Rule LayerConnection
ruleLayerConnection
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLayerConnectionAccess().getGroup()); }
(rule__LayerConnection__Group__0)
{ after(grammarAccess.getLayerConnectionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSAPoint
entryRuleSAPoint 
:
{ before(grammarAccess.getSAPointRule()); }
	 ruleSAPoint
{ after(grammarAccess.getSAPointRule()); } 
	 EOF 
;

// Rule SAPoint
ruleSAPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSAPointAccess().getAlternatives()); }
(rule__SAPoint__Alternatives)
{ after(grammarAccess.getSAPointAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRefSAPoint
entryRuleRefSAPoint 
:
{ before(grammarAccess.getRefSAPointRule()); }
	 ruleRefSAPoint
{ after(grammarAccess.getRefSAPointRule()); } 
	 EOF 
;

// Rule RefSAPoint
ruleRefSAPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRefSAPointAccess().getGroup()); }
(rule__RefSAPoint__Group__0)
{ after(grammarAccess.getRefSAPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRelaySAPoint
entryRuleRelaySAPoint 
:
{ before(grammarAccess.getRelaySAPointRule()); }
	 ruleRelaySAPoint
{ after(grammarAccess.getRelaySAPointRule()); } 
	 EOF 
;

// Rule RelaySAPoint
ruleRelaySAPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRelaySAPointAccess().getGroup()); }
(rule__RelaySAPoint__Group__0)
{ after(grammarAccess.getRelaySAPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSPPoint
entryRuleSPPoint 
:
{ before(grammarAccess.getSPPointRule()); }
	 ruleSPPoint
{ after(grammarAccess.getSPPointRule()); } 
	 EOF 
;

// Rule SPPoint
ruleSPPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSPPointAccess().getGroup()); }
(rule__SPPoint__Group__0)
{ after(grammarAccess.getSPPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleActorRef
entryRuleActorRef 
:
{ before(grammarAccess.getActorRefRule()); }
	 ruleActorRef
{ after(grammarAccess.getActorRefRule()); } 
	 EOF 
;

// Rule ActorRef
ruleActorRef
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getActorRefAccess().getGroup()); }
(rule__ActorRef__Group__0)
{ after(grammarAccess.getActorRefAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleMULTIPLICITY
entryRuleMULTIPLICITY 
:
{ before(grammarAccess.getMULTIPLICITYRule()); }
	 ruleMULTIPLICITY
{ after(grammarAccess.getMULTIPLICITYRule()); } 
	 EOF 
;

// Rule MULTIPLICITY
ruleMULTIPLICITY
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getMULTIPLICITYAccess().getGroup()); }
(rule__MULTIPLICITY__Group__0)
{ after(grammarAccess.getMULTIPLICITYAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAnnotationTargetType
entryRuleAnnotationTargetType 
:
{ before(grammarAccess.getAnnotationTargetTypeRule()); }
	 ruleAnnotationTargetType
{ after(grammarAccess.getAnnotationTargetTypeRule()); } 
	 EOF 
;

// Rule AnnotationTargetType
ruleAnnotationTargetType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getAlternatives()); }
(rule__AnnotationTargetType__Alternatives)
{ after(grammarAccess.getAnnotationTargetTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleStateGraphNode
entryRuleStateGraphNode 
:
{ before(grammarAccess.getStateGraphNodeRule()); }
	 ruleStateGraphNode
{ after(grammarAccess.getStateGraphNodeRule()); } 
	 EOF 
;

// Rule StateGraphNode
ruleStateGraphNode
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStateGraphNodeAccess().getAlternatives()); }
(rule__StateGraphNode__Alternatives)
{ after(grammarAccess.getStateGraphNodeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Entry rule entryRuleStateGraph
entryRuleStateGraph 
:
{ before(grammarAccess.getStateGraphRule()); }
	 ruleStateGraph
{ after(grammarAccess.getStateGraphRule()); } 
	 EOF 
;

// Rule StateGraph
ruleStateGraph
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStateGraphAccess().getGroup()); }
(rule__StateGraph__Group__0)
{ after(grammarAccess.getStateGraphAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStateMachine
entryRuleStateMachine 
:
{ before(grammarAccess.getStateMachineRule()); }
	 ruleStateMachine
{ after(grammarAccess.getStateMachineRule()); } 
	 EOF 
;

// Rule StateMachine
ruleStateMachine
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStateMachineAccess().getGroup()); }
(rule__StateMachine__Group__0)
{ after(grammarAccess.getStateMachineAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleState
entryRuleState 
:
{ before(grammarAccess.getStateRule()); }
	 ruleState
{ after(grammarAccess.getStateRule()); } 
	 EOF 
;

// Rule State
ruleState
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStateAccess().getAlternatives()); }
(rule__State__Alternatives)
{ after(grammarAccess.getStateAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSimpleState
entryRuleSimpleState 
:
{ before(grammarAccess.getSimpleStateRule()); }
	 ruleSimpleState
{ after(grammarAccess.getSimpleStateRule()); } 
	 EOF 
;

// Rule SimpleState
ruleSimpleState
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSimpleStateAccess().getGroup()); }
(rule__SimpleState__Group__0)
{ after(grammarAccess.getSimpleStateAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRefinedState
entryRuleRefinedState 
:
{ before(grammarAccess.getRefinedStateRule()); }
	 ruleRefinedState
{ after(grammarAccess.getRefinedStateRule()); } 
	 EOF 
;

// Rule RefinedState
ruleRefinedState
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRefinedStateAccess().getGroup()); }
(rule__RefinedState__Group__0)
{ after(grammarAccess.getRefinedStateAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDetailCode
entryRuleDetailCode 
:
{ before(grammarAccess.getDetailCodeRule()); }
	 ruleDetailCode
{ after(grammarAccess.getDetailCodeRule()); } 
	 EOF 
;

// Rule DetailCode
ruleDetailCode
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDetailCodeAccess().getGroup()); }
(rule__DetailCode__Group__0)
{ after(grammarAccess.getDetailCodeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTrPoint
entryRuleTrPoint 
:
{ before(grammarAccess.getTrPointRule()); }
	 ruleTrPoint
{ after(grammarAccess.getTrPointRule()); } 
	 EOF 
;

// Rule TrPoint
ruleTrPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTrPointAccess().getAlternatives()); }
(rule__TrPoint__Alternatives)
{ after(grammarAccess.getTrPointAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTransitionPoint
entryRuleTransitionPoint 
:
{ before(grammarAccess.getTransitionPointRule()); }
	 ruleTransitionPoint
{ after(grammarAccess.getTransitionPointRule()); } 
	 EOF 
;

// Rule TransitionPoint
ruleTransitionPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTransitionPointAccess().getGroup()); }
(rule__TransitionPoint__Group__0)
{ after(grammarAccess.getTransitionPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEntryPoint
entryRuleEntryPoint 
:
{ before(grammarAccess.getEntryPointRule()); }
	 ruleEntryPoint
{ after(grammarAccess.getEntryPointRule()); } 
	 EOF 
;

// Rule EntryPoint
ruleEntryPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEntryPointAccess().getGroup()); }
(rule__EntryPoint__Group__0)
{ after(grammarAccess.getEntryPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleExitPoint
entryRuleExitPoint 
:
{ before(grammarAccess.getExitPointRule()); }
	 ruleExitPoint
{ after(grammarAccess.getExitPointRule()); } 
	 EOF 
;

// Rule ExitPoint
ruleExitPoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getExitPointAccess().getGroup()); }
(rule__ExitPoint__Group__0)
{ after(grammarAccess.getExitPointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleChoicePoint
entryRuleChoicePoint 
:
{ before(grammarAccess.getChoicePointRule()); }
	 ruleChoicePoint
{ after(grammarAccess.getChoicePointRule()); } 
	 EOF 
;

// Rule ChoicePoint
ruleChoicePoint
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getChoicePointAccess().getGroup()); }
(rule__ChoicePoint__Group__0)
{ after(grammarAccess.getChoicePointAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTransition
entryRuleTransition 
:
{ before(grammarAccess.getTransitionRule()); }
	 ruleTransition
{ after(grammarAccess.getTransitionRule()); } 
	 EOF 
;

// Rule Transition
ruleTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTransitionAccess().getAlternatives()); }
(rule__Transition__Alternatives)
{ after(grammarAccess.getTransitionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleNonInitialTransition
entryRuleNonInitialTransition 
:
{ before(grammarAccess.getNonInitialTransitionRule()); }
	 ruleNonInitialTransition
{ after(grammarAccess.getNonInitialTransitionRule()); } 
	 EOF 
;

// Rule NonInitialTransition
ruleNonInitialTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); }
(rule__NonInitialTransition__Alternatives)
{ after(grammarAccess.getNonInitialTransitionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTransitionChainStartTransition
entryRuleTransitionChainStartTransition 
:
{ before(grammarAccess.getTransitionChainStartTransitionRule()); }
	 ruleTransitionChainStartTransition
{ after(grammarAccess.getTransitionChainStartTransitionRule()); } 
	 EOF 
;

// Rule TransitionChainStartTransition
ruleTransitionChainStartTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); }
(rule__TransitionChainStartTransition__Alternatives)
{ after(grammarAccess.getTransitionChainStartTransitionAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleInitialTransition
entryRuleInitialTransition 
:
{ before(grammarAccess.getInitialTransitionRule()); }
	 ruleInitialTransition
{ after(grammarAccess.getInitialTransitionRule()); } 
	 EOF 
;

// Rule InitialTransition
ruleInitialTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getInitialTransitionAccess().getGroup()); }
(rule__InitialTransition__Group__0)
{ after(grammarAccess.getInitialTransitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleContinuationTransition
entryRuleContinuationTransition 
:
{ before(grammarAccess.getContinuationTransitionRule()); }
	 ruleContinuationTransition
{ after(grammarAccess.getContinuationTransitionRule()); } 
	 EOF 
;

// Rule ContinuationTransition
ruleContinuationTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getContinuationTransitionAccess().getGroup()); }
(rule__ContinuationTransition__Group__0)
{ after(grammarAccess.getContinuationTransitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTriggeredTransition
entryRuleTriggeredTransition 
:
{ before(grammarAccess.getTriggeredTransitionRule()); }
	 ruleTriggeredTransition
{ after(grammarAccess.getTriggeredTransitionRule()); } 
	 EOF 
;

// Rule TriggeredTransition
ruleTriggeredTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getGroup()); }
(rule__TriggeredTransition__Group__0)
{ after(grammarAccess.getTriggeredTransitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleGuardedTransition
entryRuleGuardedTransition 
:
{ before(grammarAccess.getGuardedTransitionRule()); }
	 ruleGuardedTransition
{ after(grammarAccess.getGuardedTransitionRule()); } 
	 EOF 
;

// Rule GuardedTransition
ruleGuardedTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getGuardedTransitionAccess().getGroup()); }
(rule__GuardedTransition__Group__0)
{ after(grammarAccess.getGuardedTransitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleCPBranchTransition
entryRuleCPBranchTransition 
:
{ before(grammarAccess.getCPBranchTransitionRule()); }
	 ruleCPBranchTransition
{ after(grammarAccess.getCPBranchTransitionRule()); } 
	 EOF 
;

// Rule CPBranchTransition
ruleCPBranchTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getGroup()); }
(rule__CPBranchTransition__Group__0)
{ after(grammarAccess.getCPBranchTransitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRefinedTransition
entryRuleRefinedTransition 
:
{ before(grammarAccess.getRefinedTransitionRule()); }
	 ruleRefinedTransition
{ after(grammarAccess.getRefinedTransitionRule()); } 
	 EOF 
;

// Rule RefinedTransition
ruleRefinedTransition
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRefinedTransitionAccess().getGroup()); }
(rule__RefinedTransition__Group__0)
{ after(grammarAccess.getRefinedTransitionAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTransitionTerminal
entryRuleTransitionTerminal 
:
{ before(grammarAccess.getTransitionTerminalRule()); }
	 ruleTransitionTerminal
{ after(grammarAccess.getTransitionTerminalRule()); } 
	 EOF 
;

// Rule TransitionTerminal
ruleTransitionTerminal
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTransitionTerminalAccess().getAlternatives()); }
(rule__TransitionTerminal__Alternatives)
{ after(grammarAccess.getTransitionTerminalAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStateTerminal
entryRuleStateTerminal 
:
{ before(grammarAccess.getStateTerminalRule()); }
	 ruleStateTerminal
{ after(grammarAccess.getStateTerminalRule()); } 
	 EOF 
;

// Rule StateTerminal
ruleStateTerminal
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStateTerminalAccess().getStateAssignment()); }
(rule__StateTerminal__StateAssignment)
{ after(grammarAccess.getStateTerminalAccess().getStateAssignment()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTrPointTerminal
entryRuleTrPointTerminal 
:
{ before(grammarAccess.getTrPointTerminalRule()); }
	 ruleTrPointTerminal
{ after(grammarAccess.getTrPointTerminalRule()); } 
	 EOF 
;

// Rule TrPointTerminal
ruleTrPointTerminal
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTrPointTerminalAccess().getGroup()); }
(rule__TrPointTerminal__Group__0)
{ after(grammarAccess.getTrPointTerminalAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSubStateTrPointTerminal
entryRuleSubStateTrPointTerminal 
:
{ before(grammarAccess.getSubStateTrPointTerminalRule()); }
	 ruleSubStateTrPointTerminal
{ after(grammarAccess.getSubStateTrPointTerminalRule()); } 
	 EOF 
;

// Rule SubStateTrPointTerminal
ruleSubStateTrPointTerminal
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getGroup()); }
(rule__SubStateTrPointTerminal__Group__0)
{ after(grammarAccess.getSubStateTrPointTerminalAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleChoicepointTerminal
entryRuleChoicepointTerminal 
:
{ before(grammarAccess.getChoicepointTerminalRule()); }
	 ruleChoicepointTerminal
{ after(grammarAccess.getChoicepointTerminalRule()); } 
	 EOF 
;

// Rule ChoicepointTerminal
ruleChoicepointTerminal
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getChoicepointTerminalAccess().getGroup()); }
(rule__ChoicepointTerminal__Group__0)
{ after(grammarAccess.getChoicepointTerminalAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleTrigger
entryRuleTrigger 
:
{ before(grammarAccess.getTriggerRule()); }
	 ruleTrigger
{ after(grammarAccess.getTriggerRule()); } 
	 EOF 
;

// Rule Trigger
ruleTrigger
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getTriggerAccess().getGroup()); }
(rule__Trigger__Group__0)
{ after(grammarAccess.getTriggerAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleMessageFromIf
entryRuleMessageFromIf 
:
{ before(grammarAccess.getMessageFromIfRule()); }
	 ruleMessageFromIf
{ after(grammarAccess.getMessageFromIfRule()); } 
	 EOF 
;

// Rule MessageFromIf
ruleMessageFromIf
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getMessageFromIfAccess().getGroup()); }
(rule__MessageFromIf__Group__0)
{ after(grammarAccess.getMessageFromIfAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleGuard
entryRuleGuard 
:
{ before(grammarAccess.getGuardRule()); }
	 ruleGuard
{ after(grammarAccess.getGuardRule()); } 
	 EOF 
;

// Rule Guard
ruleGuard
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getGuardAccess().getGroup()); }
(rule__Guard__Group__0)
{ after(grammarAccess.getGuardAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleProtocolSemantics
entryRuleProtocolSemantics 
:
{ before(grammarAccess.getProtocolSemanticsRule()); }
	 ruleProtocolSemantics
{ after(grammarAccess.getProtocolSemanticsRule()); } 
	 EOF 
;

// Rule ProtocolSemantics
ruleProtocolSemantics
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getProtocolSemanticsAccess().getGroup()); }
(rule__ProtocolSemantics__Group__0)
{ after(grammarAccess.getProtocolSemanticsAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSemanticsRule
entryRuleSemanticsRule 
:
{ before(grammarAccess.getSemanticsRuleRule()); }
	 ruleSemanticsRule
{ after(grammarAccess.getSemanticsRuleRule()); } 
	 EOF 
;

// Rule SemanticsRule
ruleSemanticsRule
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSemanticsRuleAccess().getAlternatives()); }
(rule__SemanticsRule__Alternatives)
{ after(grammarAccess.getSemanticsRuleAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleInSemanticsRule
entryRuleInSemanticsRule 
:
{ before(grammarAccess.getInSemanticsRuleRule()); }
	 ruleInSemanticsRule
{ after(grammarAccess.getInSemanticsRuleRule()); } 
	 EOF 
;

// Rule InSemanticsRule
ruleInSemanticsRule
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getGroup()); }
(rule__InSemanticsRule__Group__0)
{ after(grammarAccess.getInSemanticsRuleAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleOutSemanticsRule
entryRuleOutSemanticsRule 
:
{ before(grammarAccess.getOutSemanticsRuleRule()); }
	 ruleOutSemanticsRule
{ after(grammarAccess.getOutSemanticsRuleRule()); } 
	 EOF 
;

// Rule OutSemanticsRule
ruleOutSemanticsRule
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getGroup()); }
(rule__OutSemanticsRule__Group__0)
{ after(grammarAccess.getOutSemanticsRuleAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAnnotation
entryRuleAnnotation 
:
{ before(grammarAccess.getAnnotationRule()); }
	 ruleAnnotation
{ after(grammarAccess.getAnnotationRule()); } 
	 EOF 
;

// Rule Annotation
ruleAnnotation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAnnotationAccess().getGroup()); }
(rule__Annotation__Group__0)
{ after(grammarAccess.getAnnotationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleKeyValue
entryRuleKeyValue 
:
{ before(grammarAccess.getKeyValueRule()); }
	 ruleKeyValue
{ after(grammarAccess.getKeyValueRule()); } 
	 EOF 
;

// Rule KeyValue
ruleKeyValue
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getKeyValueAccess().getGroup()); }
(rule__KeyValue__Group__0)
{ after(grammarAccess.getKeyValueAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAnnotationType
entryRuleAnnotationType 
:
{ before(grammarAccess.getAnnotationTypeRule()); }
	 ruleAnnotationType
{ after(grammarAccess.getAnnotationTypeRule()); } 
	 EOF 
;

// Rule AnnotationType
ruleAnnotationType
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAnnotationTypeAccess().getGroup()); }
(rule__AnnotationType__Group__0)
{ after(grammarAccess.getAnnotationTypeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleAnnotationAttribute
entryRuleAnnotationAttribute 
:
{ before(grammarAccess.getAnnotationAttributeRule()); }
	 ruleAnnotationAttribute
{ after(grammarAccess.getAnnotationAttributeRule()); } 
	 EOF 
;

// Rule AnnotationAttribute
ruleAnnotationAttribute
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); }
(rule__AnnotationAttribute__Alternatives)
{ after(grammarAccess.getAnnotationAttributeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleSimpleAnnotationAttribute
entryRuleSimpleAnnotationAttribute 
:
{ before(grammarAccess.getSimpleAnnotationAttributeRule()); }
	 ruleSimpleAnnotationAttribute
{ after(grammarAccess.getSimpleAnnotationAttributeRule()); } 
	 EOF 
;

// Rule SimpleAnnotationAttribute
ruleSimpleAnnotationAttribute
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getGroup()); }
(rule__SimpleAnnotationAttribute__Group__0)
{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleEnumAnnotationAttribute
entryRuleEnumAnnotationAttribute 
:
{ before(grammarAccess.getEnumAnnotationAttributeRule()); }
	 ruleEnumAnnotationAttribute
{ after(grammarAccess.getEnumAnnotationAttributeRule()); } 
	 EOF 
;

// Rule EnumAnnotationAttribute
ruleEnumAnnotationAttribute
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup()); }
(rule__EnumAnnotationAttribute__Group__0)
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleImport
entryRuleImport 
:
{ before(grammarAccess.getImportRule()); }
	 ruleImport
{ after(grammarAccess.getImportRule()); } 
	 EOF 
;

// Rule Import
ruleImport
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getImportAccess().getGroup()); }
(rule__Import__Group__0)
{ after(grammarAccess.getImportAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleImportedFQN
entryRuleImportedFQN 
:
{ before(grammarAccess.getImportedFQNRule()); }
	 ruleImportedFQN
{ after(grammarAccess.getImportedFQNRule()); } 
	 EOF 
;

// Rule ImportedFQN
ruleImportedFQN
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getImportedFQNAccess().getGroup()); }
(rule__ImportedFQN__Group__0)
{ after(grammarAccess.getImportedFQNAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleDocumentation
entryRuleDocumentation 
:
{ before(grammarAccess.getDocumentationRule()); }
	 ruleDocumentation
{ after(grammarAccess.getDocumentationRule()); } 
	 EOF 
;

// Rule Documentation
ruleDocumentation
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDocumentationAccess().getGroup()); }
(rule__Documentation__Group__0)
{ after(grammarAccess.getDocumentationAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}







// Entry rule entryRuleLiteral
entryRuleLiteral 
:
{ before(grammarAccess.getLiteralRule()); }
	 ruleLiteral
{ after(grammarAccess.getLiteralRule()); } 
	 EOF 
;

// Rule Literal
ruleLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getLiteralAccess().getAlternatives()); }
(rule__Literal__Alternatives)
{ after(grammarAccess.getLiteralAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleBooleanLiteral
entryRuleBooleanLiteral 
:
{ before(grammarAccess.getBooleanLiteralRule()); }
	 ruleBooleanLiteral
{ after(grammarAccess.getBooleanLiteralRule()); } 
	 EOF 
;

// Rule BooleanLiteral
ruleBooleanLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getBooleanLiteralAccess().getGroup()); }
(rule__BooleanLiteral__Group__0)
{ after(grammarAccess.getBooleanLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleNumberLiteral
entryRuleNumberLiteral 
:
{ before(grammarAccess.getNumberLiteralRule()); }
	 ruleNumberLiteral
{ after(grammarAccess.getNumberLiteralRule()); } 
	 EOF 
;

// Rule NumberLiteral
ruleNumberLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getNumberLiteralAccess().getAlternatives()); }
(rule__NumberLiteral__Alternatives)
{ after(grammarAccess.getNumberLiteralAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleRealLiteral
entryRuleRealLiteral 
:
{ before(grammarAccess.getRealLiteralRule()); }
	 ruleRealLiteral
{ after(grammarAccess.getRealLiteralRule()); } 
	 EOF 
;

// Rule RealLiteral
ruleRealLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRealLiteralAccess().getGroup()); }
(rule__RealLiteral__Group__0)
{ after(grammarAccess.getRealLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleIntLiteral
entryRuleIntLiteral 
:
{ before(grammarAccess.getIntLiteralRule()); }
	 ruleIntLiteral
{ after(grammarAccess.getIntLiteralRule()); } 
	 EOF 
;

// Rule IntLiteral
ruleIntLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIntLiteralAccess().getGroup()); }
(rule__IntLiteral__Group__0)
{ after(grammarAccess.getIntLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleStringLiteral
entryRuleStringLiteral 
:
{ before(grammarAccess.getStringLiteralRule()); }
	 ruleStringLiteral
{ after(grammarAccess.getStringLiteralRule()); } 
	 EOF 
;

// Rule StringLiteral
ruleStringLiteral
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getStringLiteralAccess().getGroup()); }
(rule__StringLiteral__Group__0)
{ after(grammarAccess.getStringLiteralAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Entry rule entryRuleInteger
entryRuleInteger 
:
{ before(grammarAccess.getIntegerRule()); }
	 ruleInteger
{ after(grammarAccess.getIntegerRule()); } 
	 EOF 
;

// Rule Integer
ruleInteger
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getIntegerAccess().getAlternatives()); }
(rule__Integer__Alternatives)
{ after(grammarAccess.getIntegerAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule SignedInteger
ruleSignedInteger
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getSignedIntegerAccess().getGroup()); }
(rule__SignedInteger__Group__0)
{ after(grammarAccess.getSignedIntegerAccess().getGroup()); }
)

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



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

// Rule Hexadecimal
ruleHexadecimal
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getHexadecimalAccess().getHEXTerminalRuleCall()); }
	RULE_HEX
{ after(grammarAccess.getHexadecimalAccess().getHEXTerminalRuleCall()); }
)

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



// Entry rule entryRuleReal
entryRuleReal 
:
{ before(grammarAccess.getRealRule()); }
	 ruleReal
{ after(grammarAccess.getRealRule()); } 
	 EOF 
;

// Rule Real
ruleReal
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getRealAccess().getAlternatives()); }
(rule__Real__Alternatives)
{ after(grammarAccess.getRealAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



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

// Rule Decimal
ruleDecimal
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDecimalAccess().getGroup()); }
(rule__Decimal__Group__0)
{ after(grammarAccess.getDecimalAccess().getGroup()); }
)

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



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

// Rule DotDecimal
ruleDotDecimal
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDotDecimalAccess().getGroup()); }
(rule__DotDecimal__Group__0)
{ after(grammarAccess.getDotDecimalAccess().getGroup()); }
)

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



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

// Rule DecimalDot
ruleDecimalDot
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDecimalDotAccess().getGroup()); }
(rule__DecimalDot__Group__0)
{ after(grammarAccess.getDecimalDotAccess().getGroup()); }
)

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



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

// Rule DecimalExp
ruleDecimalExp
    @init {
		HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getDecimalExpAccess().getGroup()); }
(rule__DecimalExp__Group__0)
{ after(grammarAccess.getDecimalExpAccess().getGroup()); }
)

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



// Entry rule entryRuleFQN
entryRuleFQN 
:
{ before(grammarAccess.getFQNRule()); }
	 ruleFQN
{ after(grammarAccess.getFQNRule()); } 
	 EOF 
;

// Rule FQN
ruleFQN
    @init {
		int stackSize = keepStackSize();
    }
	:
(
{ before(grammarAccess.getFQNAccess().getGroup()); }
(rule__FQN__Group__0)
{ after(grammarAccess.getFQNAccess().getGroup()); }
)

;
finally {
	restoreStackSize(stackSize);
}




// Rule CommunicationType
ruleCommunicationType
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCommunicationTypeAccess().getAlternatives()); }
(rule__CommunicationType__Alternatives)
{ after(grammarAccess.getCommunicationTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule ReferenceType
ruleReferenceType
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getReferenceTypeAccess().getAlternatives()); }
(rule__ReferenceType__Alternatives)
{ after(grammarAccess.getReferenceTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}





// Rule ComponentCommunicationType
ruleComponentCommunicationType
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); }
(rule__ComponentCommunicationType__Alternatives)
{ after(grammarAccess.getComponentCommunicationTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



// Rule LiteralType
ruleLiteralType
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLiteralTypeAccess().getAlternatives()); }
(rule__LiteralType__Alternatives)
{ after(grammarAccess.getLiteralTypeAccess().getAlternatives()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__RoomModel__Alternatives_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getPrimitiveTypesAssignment_5_0()); }
(rule__RoomModel__PrimitiveTypesAssignment_5_0)
{ after(grammarAccess.getRoomModelAccess().getPrimitiveTypesAssignment_5_0()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getEnumerationTypesAssignment_5_1()); }
(rule__RoomModel__EnumerationTypesAssignment_5_1)
{ after(grammarAccess.getRoomModelAccess().getEnumerationTypesAssignment_5_1()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getExternalTypesAssignment_5_2()); }
(rule__RoomModel__ExternalTypesAssignment_5_2)
{ after(grammarAccess.getRoomModelAccess().getExternalTypesAssignment_5_2()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getDataClassesAssignment_5_3()); }
(rule__RoomModel__DataClassesAssignment_5_3)
{ after(grammarAccess.getRoomModelAccess().getDataClassesAssignment_5_3()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getProtocolClassesAssignment_5_4()); }
(rule__RoomModel__ProtocolClassesAssignment_5_4)
{ after(grammarAccess.getRoomModelAccess().getProtocolClassesAssignment_5_4()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getActorClassesAssignment_5_5()); }
(rule__RoomModel__ActorClassesAssignment_5_5)
{ after(grammarAccess.getRoomModelAccess().getActorClassesAssignment_5_5()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getSubSystemClassesAssignment_5_6()); }
(rule__RoomModel__SubSystemClassesAssignment_5_6)
{ after(grammarAccess.getRoomModelAccess().getSubSystemClassesAssignment_5_6()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getSystemsAssignment_5_7()); }
(rule__RoomModel__SystemsAssignment_5_7)
{ after(grammarAccess.getRoomModelAccess().getSystemsAssignment_5_7()); }
)

    |(
{ before(grammarAccess.getRoomModelAccess().getAnnotationTypesAssignment_5_8()); }
(rule__RoomModel__AnnotationTypesAssignment_5_8)
{ after(grammarAccess.getRoomModelAccess().getAnnotationTypesAssignment_5_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StructureClass__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStructureClassAccess().getActorContainerClassParserRuleCall_0()); }
	ruleActorContainerClass
{ after(grammarAccess.getStructureClassAccess().getActorContainerClassParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getStructureClassAccess().getLogicalSystemParserRuleCall_1()); }
	ruleLogicalSystem
{ after(grammarAccess.getStructureClassAccess().getLogicalSystemParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorContainerClass__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorContainerClassAccess().getActorClassParserRuleCall_0()); }
	ruleActorClass
{ after(grammarAccess.getActorContainerClassAccess().getActorClassParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getActorContainerClassAccess().getSubSystemClassParserRuleCall_1()); }
	ruleSubSystemClass
{ after(grammarAccess.getActorContainerClassAccess().getSubSystemClassParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataTypeAccess().getPrimitiveTypeParserRuleCall_0()); }
	rulePrimitiveType
{ after(grammarAccess.getDataTypeAccess().getPrimitiveTypeParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getDataTypeAccess().getEnumerationTypeParserRuleCall_1()); }
	ruleEnumerationType
{ after(grammarAccess.getDataTypeAccess().getEnumerationTypeParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getDataTypeAccess().getComplexTypeParserRuleCall_2()); }
	ruleComplexType
{ after(grammarAccess.getDataTypeAccess().getComplexTypeParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ComplexType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComplexTypeAccess().getDataClassParserRuleCall_0()); }
	ruleDataClass
{ after(grammarAccess.getComplexTypeAccess().getDataClassParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getComplexTypeAccess().getExternalTypeParserRuleCall_1()); }
	ruleExternalType
{ after(grammarAccess.getComplexTypeAccess().getExternalTypeParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Alternatives_9
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getOperationsAssignment_9_0()); }
(rule__DataClass__OperationsAssignment_9_0)
{ after(grammarAccess.getDataClassAccess().getOperationsAssignment_9_0()); }
)

    |(
{ before(grammarAccess.getDataClassAccess().getStructorsAssignment_9_1()); }
(rule__DataClass__StructorsAssignment_9_1)
{ after(grammarAccess.getDataClassAccess().getStructorsAssignment_9_1()); }
)

    |(
{ before(grammarAccess.getDataClassAccess().getAttributesAssignment_9_2()); }
(rule__DataClass__AttributesAssignment_9_2)
{ after(grammarAccess.getDataClassAccess().getAttributesAssignment_9_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Alternatives_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getVoidKeyword_6_1_0()); }

	'void' 

{ after(grammarAccess.getStandardOperationAccess().getVoidKeyword_6_1_0()); }
)

    |(
{ before(grammarAccess.getStandardOperationAccess().getReturnTypeAssignment_6_1_1()); }
(rule__StandardOperation__ReturnTypeAssignment_6_1_1)
{ after(grammarAccess.getStandardOperationAccess().getReturnTypeAssignment_6_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Alternatives_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getGroup_5_0()); }
(rule__PortOperation__Group_5_0__0)
{ after(grammarAccess.getPortOperationAccess().getGroup_5_0()); }
)

    |(
{ before(grammarAccess.getPortOperationAccess().getGroup_5_1()); }
(rule__PortOperation__Group_5_1__0)
{ after(grammarAccess.getPortOperationAccess().getGroup_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Alternatives_5_0_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getVoidKeyword_5_0_1_0()); }

	'void' 

{ after(grammarAccess.getPortOperationAccess().getVoidKeyword_5_0_1_0()); }
)

    |(
{ before(grammarAccess.getPortOperationAccess().getReturnTypeAssignment_5_0_1_1()); }
(rule__PortOperation__ReturnTypeAssignment_5_0_1_1)
{ after(grammarAccess.getPortOperationAccess().getReturnTypeAssignment_5_0_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ClassStructor__NameAlternatives_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getClassStructorAccess().getNameCtorKeyword_0_0_0()); }

	'ctor' 

{ after(grammarAccess.getClassStructorAccess().getNameCtorKeyword_0_0_0()); }
)

    |(
{ before(grammarAccess.getClassStructorAccess().getNameDtorKeyword_0_0_1()); }

	'dtor' 

{ after(grammarAccess.getClassStructorAccess().getNameDtorKeyword_0_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GeneralProtocolClass__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGeneralProtocolClassAccess().getProtocolClassParserRuleCall_0()); }
	ruleProtocolClass
{ after(grammarAccess.getGeneralProtocolClassAccess().getProtocolClassParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getGeneralProtocolClassAccess().getCompoundProtocolClassParserRuleCall_1()); }
	ruleCompoundProtocolClass
{ after(grammarAccess.getGeneralProtocolClassAccess().getCompoundProtocolClassParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Alternatives_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getMsgHandlersAssignment_3_0()); }
(rule__PortClass__MsgHandlersAssignment_3_0)
{ after(grammarAccess.getPortClassAccess().getMsgHandlersAssignment_3_0()); }
)

    |(
{ before(grammarAccess.getPortClassAccess().getOperationsAssignment_3_1()); }
(rule__PortClass__OperationsAssignment_3_1)
{ after(grammarAccess.getPortClassAccess().getOperationsAssignment_3_1()); }
)

    |(
{ before(grammarAccess.getPortClassAccess().getAttributesAssignment_3_2()); }
(rule__PortClass__AttributesAssignment_3_2)
{ after(grammarAccess.getPortClassAccess().getAttributesAssignment_3_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MessageHandler__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageHandlerAccess().getInMessageHandlerParserRuleCall_0()); }
	ruleInMessageHandler
{ after(grammarAccess.getMessageHandlerAccess().getInMessageHandlerParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getMessageHandlerAccess().getOutMessageHandlerParserRuleCall_1()); }
	ruleOutMessageHandler
{ after(grammarAccess.getMessageHandlerAccess().getOutMessageHandlerParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Alternatives_7_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getServiceProvisionPointsAssignment_7_2_0()); }
(rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0)
{ after(grammarAccess.getActorClassAccess().getServiceProvisionPointsAssignment_7_2_0()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getInterfacePortsAssignment_7_2_1()); }
(rule__ActorClass__InterfacePortsAssignment_7_2_1)
{ after(grammarAccess.getActorClassAccess().getInterfacePortsAssignment_7_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Alternatives_8_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getConnectionsAssignment_8_6_0()); }
(rule__ActorClass__ConnectionsAssignment_8_6_0)
{ after(grammarAccess.getActorClassAccess().getConnectionsAssignment_8_6_0()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getBindingsAssignment_8_6_1()); }
(rule__ActorClass__BindingsAssignment_8_6_1)
{ after(grammarAccess.getActorClassAccess().getBindingsAssignment_8_6_1()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getServiceImplementationsAssignment_8_6_2()); }
(rule__ActorClass__ServiceImplementationsAssignment_8_6_2)
{ after(grammarAccess.getActorClassAccess().getServiceImplementationsAssignment_8_6_2()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getAttributesAssignment_8_6_3()); }
(rule__ActorClass__AttributesAssignment_8_6_3)
{ after(grammarAccess.getActorClassAccess().getAttributesAssignment_8_6_3()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getActorRefsAssignment_8_6_4()); }
(rule__ActorClass__ActorRefsAssignment_8_6_4)
{ after(grammarAccess.getActorClassAccess().getActorRefsAssignment_8_6_4()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getServiceAccessPointsAssignment_8_6_5()); }
(rule__ActorClass__ServiceAccessPointsAssignment_8_6_5)
{ after(grammarAccess.getActorClassAccess().getServiceAccessPointsAssignment_8_6_5()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getInternalPortsAssignment_8_6_6()); }
(rule__ActorClass__InternalPortsAssignment_8_6_6)
{ after(grammarAccess.getActorClassAccess().getInternalPortsAssignment_8_6_6()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getExternalPortsAssignment_8_6_7()); }
(rule__ActorClass__ExternalPortsAssignment_8_6_7)
{ after(grammarAccess.getActorClassAccess().getExternalPortsAssignment_8_6_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Alternatives_9_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getOperationsAssignment_9_4_0()); }
(rule__ActorClass__OperationsAssignment_9_4_0)
{ after(grammarAccess.getActorClassAccess().getOperationsAssignment_9_4_0()); }
)

    |(
{ before(grammarAccess.getActorClassAccess().getStructorsAssignment_9_4_1()); }
(rule__ActorClass__StructorsAssignment_9_4_1)
{ after(grammarAccess.getActorClassAccess().getStructorsAssignment_9_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InterfaceItem__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInterfaceItemAccess().getPortParserRuleCall_0()); }
	rulePort
{ after(grammarAccess.getInterfaceItemAccess().getPortParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getInterfaceItemAccess().getSAPParserRuleCall_1()); }
	ruleSAP
{ after(grammarAccess.getInterfaceItemAccess().getSAPParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getInterfaceItemAccess().getSPPParserRuleCall_2()); }
	ruleSPP
{ after(grammarAccess.getInterfaceItemAccess().getSPPParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Alternatives_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getConnectionsAssignment_5_0()); }
(rule__LogicalSystem__ConnectionsAssignment_5_0)
{ after(grammarAccess.getLogicalSystemAccess().getConnectionsAssignment_5_0()); }
)

    |(
{ before(grammarAccess.getLogicalSystemAccess().getBindingsAssignment_5_1()); }
(rule__LogicalSystem__BindingsAssignment_5_1)
{ after(grammarAccess.getLogicalSystemAccess().getBindingsAssignment_5_1()); }
)

    |(
{ before(grammarAccess.getLogicalSystemAccess().getSubSystemsAssignment_5_2()); }
(rule__LogicalSystem__SubSystemsAssignment_5_2)
{ after(grammarAccess.getLogicalSystemAccess().getSubSystemsAssignment_5_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Alternatives_8
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsAssignment_8_0()); }
(rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0)
{ after(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsAssignment_8_0()); }
)

    |(
{ before(grammarAccess.getSubSystemClassAccess().getThreadsAssignment_8_1()); }
(rule__SubSystemClass__ThreadsAssignment_8_1)
{ after(grammarAccess.getSubSystemClassAccess().getThreadsAssignment_8_1()); }
)

    |(
{ before(grammarAccess.getSubSystemClassAccess().getConnectionsAssignment_8_2()); }
(rule__SubSystemClass__ConnectionsAssignment_8_2)
{ after(grammarAccess.getSubSystemClassAccess().getConnectionsAssignment_8_2()); }
)

    |(
{ before(grammarAccess.getSubSystemClassAccess().getBindingsAssignment_8_3()); }
(rule__SubSystemClass__BindingsAssignment_8_3)
{ after(grammarAccess.getSubSystemClassAccess().getBindingsAssignment_8_3()); }
)

    |(
{ before(grammarAccess.getSubSystemClassAccess().getActorRefsAssignment_8_4()); }
(rule__SubSystemClass__ActorRefsAssignment_8_4)
{ after(grammarAccess.getSubSystemClassAccess().getActorRefsAssignment_8_4()); }
)

    |(
{ before(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsAssignment_8_5()); }
(rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5)
{ after(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsAssignment_8_5()); }
)

    |(
{ before(grammarAccess.getSubSystemClassAccess().getRelayPortsAssignment_8_6()); }
(rule__SubSystemClass__RelayPortsAssignment_8_6)
{ after(grammarAccess.getSubSystemClassAccess().getRelayPortsAssignment_8_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SAPoint__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSAPointAccess().getRefSAPointParserRuleCall_0()); }
	ruleRefSAPoint
{ after(grammarAccess.getSAPointAccess().getRefSAPointParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getSAPointAccess().getRelaySAPointParserRuleCall_1()); }
	ruleRelaySAPoint
{ after(grammarAccess.getSAPointAccess().getRelaySAPointParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MULTIPLICITY__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMULTIPLICITYAccess().getAsteriskKeyword_1_0()); }

	'*' 

{ after(grammarAccess.getMULTIPLICITYAccess().getAsteriskKeyword_1_0()); }
)

    |(
{ before(grammarAccess.getMULTIPLICITYAccess().getINTTerminalRuleCall_1_1()); }
	RULE_INT
{ after(grammarAccess.getMULTIPLICITYAccess().getINTTerminalRuleCall_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationTargetType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getDataClassKeyword_0()); }

	'DataClass' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getDataClassKeyword_0()); }
)

    |(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getActorClassKeyword_1()); }

	'ActorClass' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getActorClassKeyword_1()); }
)

    |(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getActorBehaviorKeyword_2()); }

	'ActorBehavior' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getActorBehaviorKeyword_2()); }
)

    |(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getProtocolClassKeyword_3()); }

	'ProtocolClass' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getProtocolClassKeyword_3()); }
)

    |(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getCompoundProtocolClassKeyword_4()); }

	'CompoundProtocolClass' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getCompoundProtocolClassKeyword_4()); }
)

    |(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getSubSystemClassKeyword_5()); }

	'SubSystemClass' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getSubSystemClassKeyword_5()); }
)

    |(
{ before(grammarAccess.getAnnotationTargetTypeAccess().getLogicalSystemKeyword_6()); }

	'LogicalSystem' 

{ after(grammarAccess.getAnnotationTargetTypeAccess().getLogicalSystemKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraphNode__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); }
	ruleState
{ after(grammarAccess.getStateGraphNodeAccess().getStateParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); }
	ruleChoicePoint
{ after(grammarAccess.getStateGraphNodeAccess().getChoicePointParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); }
	ruleTrPoint
{ after(grammarAccess.getStateGraphNodeAccess().getTrPointParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateGraph__Alternatives_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getStatesAssignment_2_0()); }
(rule__StateGraph__StatesAssignment_2_0)
{ after(grammarAccess.getStateGraphAccess().getStatesAssignment_2_0()); }
)

    |(
{ before(grammarAccess.getStateGraphAccess().getTrPointsAssignment_2_1()); }
(rule__StateGraph__TrPointsAssignment_2_1)
{ after(grammarAccess.getStateGraphAccess().getTrPointsAssignment_2_1()); }
)

    |(
{ before(grammarAccess.getStateGraphAccess().getChPointsAssignment_2_2()); }
(rule__StateGraph__ChPointsAssignment_2_2)
{ after(grammarAccess.getStateGraphAccess().getChPointsAssignment_2_2()); }
)

    |(
{ before(grammarAccess.getStateGraphAccess().getTransitionsAssignment_2_3()); }
(rule__StateGraph__TransitionsAssignment_2_3)
{ after(grammarAccess.getStateGraphAccess().getTransitionsAssignment_2_3()); }
)

    |(
{ before(grammarAccess.getStateGraphAccess().getRefinedTransitionsAssignment_2_4()); }
(rule__StateGraph__RefinedTransitionsAssignment_2_4)
{ after(grammarAccess.getStateGraphAccess().getRefinedTransitionsAssignment_2_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__Alternatives_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getStatesAssignment_3_0()); }
(rule__StateMachine__StatesAssignment_3_0)
{ after(grammarAccess.getStateMachineAccess().getStatesAssignment_3_0()); }
)

    |(
{ before(grammarAccess.getStateMachineAccess().getTrPointsAssignment_3_1()); }
(rule__StateMachine__TrPointsAssignment_3_1)
{ after(grammarAccess.getStateMachineAccess().getTrPointsAssignment_3_1()); }
)

    |(
{ before(grammarAccess.getStateMachineAccess().getChPointsAssignment_3_2()); }
(rule__StateMachine__ChPointsAssignment_3_2)
{ after(grammarAccess.getStateMachineAccess().getChPointsAssignment_3_2()); }
)

    |(
{ before(grammarAccess.getStateMachineAccess().getTransitionsAssignment_3_3()); }
(rule__StateMachine__TransitionsAssignment_3_3)
{ after(grammarAccess.getStateMachineAccess().getTransitionsAssignment_3_3()); }
)

    |(
{ before(grammarAccess.getStateMachineAccess().getRefinedTransitionsAssignment_3_4()); }
(rule__StateMachine__RefinedTransitionsAssignment_3_4)
{ after(grammarAccess.getStateMachineAccess().getRefinedTransitionsAssignment_3_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__State__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); }
	ruleSimpleState
{ after(grammarAccess.getStateAccess().getSimpleStateParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); }
	ruleRefinedState
{ after(grammarAccess.getStateAccess().getRefinedStateParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TrPoint__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); }
	ruleTransitionPoint
{ after(grammarAccess.getTrPointAccess().getTransitionPointParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); }
	ruleEntryPoint
{ after(grammarAccess.getTrPointAccess().getEntryPointParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); }
	ruleExitPoint
{ after(grammarAccess.getTrPointAccess().getExitPointParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Transition__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); }
	ruleInitialTransition
{ after(grammarAccess.getTransitionAccess().getInitialTransitionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); }
	ruleNonInitialTransition
{ after(grammarAccess.getTransitionAccess().getNonInitialTransitionParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__NonInitialTransition__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); }
	ruleTransitionChainStartTransition
{ after(grammarAccess.getNonInitialTransitionAccess().getTransitionChainStartTransitionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); }
	ruleContinuationTransition
{ after(grammarAccess.getNonInitialTransitionAccess().getContinuationTransitionParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); }
	ruleCPBranchTransition
{ after(grammarAccess.getNonInitialTransitionAccess().getCPBranchTransitionParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionChainStartTransition__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); }
	ruleTriggeredTransition
{ after(grammarAccess.getTransitionChainStartTransitionAccess().getTriggeredTransitionParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); }
	ruleGuardedTransition
{ after(grammarAccess.getTransitionChainStartTransitionAccess().getGuardedTransitionParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionTerminal__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); }
	ruleStateTerminal
{ after(grammarAccess.getTransitionTerminalAccess().getStateTerminalParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); }
	ruleTrPointTerminal
{ after(grammarAccess.getTransitionTerminalAccess().getTrPointTerminalParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); }
	ruleSubStateTrPointTerminal
{ after(grammarAccess.getTransitionTerminalAccess().getSubStateTrPointTerminalParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); }
	ruleChoicepointTerminal
{ after(grammarAccess.getTransitionTerminalAccess().getChoicepointTerminalParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SemanticsRule__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); }
	ruleInSemanticsRule
{ after(grammarAccess.getSemanticsRuleAccess().getInSemanticsRuleParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); }
	ruleOutSemanticsRule
{ after(grammarAccess.getSemanticsRuleAccess().getOutSemanticsRuleParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Alternatives_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); }
(rule__InSemanticsRule__FollowUpsAssignment_3_1_0)
{ after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); }
)

    |(
{ before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1()); }
(rule__InSemanticsRule__Group_3_1_1__0)
{ after(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Alternatives_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); }
(rule__OutSemanticsRule__FollowUpsAssignment_3_1_0)
{ after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_0()); }
)

    |(
{ before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1()); }
(rule__OutSemanticsRule__Group_3_1_1__0)
{ after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Alternatives_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_0()); }
(rule__AnnotationType__TargetsAssignment_6_0)
{ after(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_0()); }
)

    |(
{ before(grammarAccess.getAnnotationTypeAccess().getGroup_6_1()); }
(rule__AnnotationType__Group_6_1__0)
{ after(grammarAccess.getAnnotationTypeAccess().getGroup_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationAttribute__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); }
	ruleSimpleAnnotationAttribute
{ after(grammarAccess.getAnnotationAttributeAccess().getSimpleAnnotationAttributeParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); }
	ruleEnumAnnotationAttribute
{ after(grammarAccess.getAnnotationAttributeAccess().getEnumAnnotationAttributeParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalAssignment_0_0()); }
(rule__SimpleAnnotationAttribute__OptionalAssignment_0_0)
{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalAssignment_0_0()); }
)

    |(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); }

	'mandatory' 

{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getMandatoryKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalAssignment_0_0()); }
(rule__EnumAnnotationAttribute__OptionalAssignment_0_0)
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalAssignment_0_0()); }
)

    |(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); }

	'mandatory' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getMandatoryKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Import__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getGroup_1_0()); }
(rule__Import__Group_1_0__0)
{ after(grammarAccess.getImportAccess().getGroup_1_0()); }
)

    |(
{ before(grammarAccess.getImportAccess().getModelKeyword_1_1()); }

	'model' 

{ after(grammarAccess.getImportAccess().getModelKeyword_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Literal__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); }
	ruleBooleanLiteral
{ after(grammarAccess.getLiteralAccess().getBooleanLiteralParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); }
	ruleNumberLiteral
{ after(grammarAccess.getLiteralAccess().getNumberLiteralParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); }
	ruleStringLiteral
{ after(grammarAccess.getLiteralAccess().getStringLiteralParserRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Alternatives_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); }

	'false' 

{ after(grammarAccess.getBooleanLiteralAccess().getFalseKeyword_1_0()); }
)

    |(
{ before(grammarAccess.getBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
(rule__BooleanLiteral__IsTrueAssignment_1_1)
{ after(grammarAccess.getBooleanLiteralAccess().getIsTrueAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__NumberLiteral__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); }
	ruleIntLiteral
{ after(grammarAccess.getNumberLiteralAccess().getIntLiteralParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); }
	ruleRealLiteral
{ after(grammarAccess.getNumberLiteralAccess().getRealLiteralParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Integer__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntegerAccess().getSignedIntegerParserRuleCall_0()); }
	ruleSignedInteger
{ after(grammarAccess.getIntegerAccess().getSignedIntegerParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getIntegerAccess().getHexadecimalParserRuleCall_1()); }
	ruleHexadecimal
{ after(grammarAccess.getIntegerAccess().getHexadecimalParserRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SignedInteger__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSignedIntegerAccess().getPlusSignKeyword_0_0()); }

	'+' 

{ after(grammarAccess.getSignedIntegerAccess().getPlusSignKeyword_0_0()); }
)

    |(
{ before(grammarAccess.getSignedIntegerAccess().getHyphenMinusKeyword_0_1()); }

	'-' 

{ after(grammarAccess.getSignedIntegerAccess().getHyphenMinusKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Real__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); }
	ruleDecimal
{ after(grammarAccess.getRealAccess().getDecimalParserRuleCall_0()); }
)

    |(
{ before(grammarAccess.getRealAccess().getDotDecimalParserRuleCall_1()); }
	ruleDotDecimal
{ after(grammarAccess.getRealAccess().getDotDecimalParserRuleCall_1()); }
)

    |(
{ before(grammarAccess.getRealAccess().getDecimalDotParserRuleCall_2()); }
	ruleDecimalDot
{ after(grammarAccess.getRealAccess().getDecimalDotParserRuleCall_2()); }
)

    |(
{ before(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_3()); }
	ruleDecimalExp
{ after(grammarAccess.getRealAccess().getDecimalExpParserRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Decimal__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); }

	'+' 

{ after(grammarAccess.getDecimalAccess().getPlusSignKeyword_0_0()); }
)

    |(
{ before(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); }

	'-' 

{ after(grammarAccess.getDecimalAccess().getHyphenMinusKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DotDecimal__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDotDecimalAccess().getPlusSignKeyword_0_0()); }

	'+' 

{ after(grammarAccess.getDotDecimalAccess().getPlusSignKeyword_0_0()); }
)

    |(
{ before(grammarAccess.getDotDecimalAccess().getHyphenMinusKeyword_0_1()); }

	'-' 

{ after(grammarAccess.getDotDecimalAccess().getHyphenMinusKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalDot__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalDotAccess().getPlusSignKeyword_0_0()); }

	'+' 

{ after(grammarAccess.getDecimalDotAccess().getPlusSignKeyword_0_0()); }
)

    |(
{ before(grammarAccess.getDecimalDotAccess().getHyphenMinusKeyword_0_1()); }

	'-' 

{ after(grammarAccess.getDecimalDotAccess().getHyphenMinusKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalExp__Alternatives_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); }

	'+' 

{ after(grammarAccess.getDecimalExpAccess().getPlusSignKeyword_0_0()); }
)

    |(
{ before(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); }

	'-' 

{ after(grammarAccess.getDecimalExpAccess().getHyphenMinusKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CommunicationType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); }
(	'eventdriven' 
)
{ after(grammarAccess.getCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); }
(	'datadriven' 
)
{ after(grammarAccess.getCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_2()); }
(	'sync' 
)
{ after(grammarAccess.getCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ReferenceType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getReferenceTypeAccess().getFIXEDEnumLiteralDeclaration_0()); }
(	'fixed' 
)
{ after(grammarAccess.getReferenceTypeAccess().getFIXEDEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getReferenceTypeAccess().getOPTIONALEnumLiteralDeclaration_1()); }
(	'optional' 
)
{ after(grammarAccess.getReferenceTypeAccess().getOPTIONALEnumLiteralDeclaration_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ComponentCommunicationType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); }
(	'eventdriven' 
)
{ after(grammarAccess.getComponentCommunicationTypeAccess().getEVENT_DRIVENEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); }
(	'datadriven' 
)
{ after(grammarAccess.getComponentCommunicationTypeAccess().getDATA_DRIVENEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); }
(	'async' 
)
{ after(grammarAccess.getComponentCommunicationTypeAccess().getASYNCHRONOUSEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); }
(	'sync' 
)
{ after(grammarAccess.getComponentCommunicationTypeAccess().getSYNCHRONOUSEnumLiteralDeclaration_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LiteralType__Alternatives
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); }
(	'ptBoolean' 
)
{ after(grammarAccess.getLiteralTypeAccess().getBOOLEnumLiteralDeclaration_0()); }
)

    |(
{ before(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); }
(	'ptInteger' 
)
{ after(grammarAccess.getLiteralTypeAccess().getINTEnumLiteralDeclaration_1()); }
)

    |(
{ before(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); }
(	'ptReal' 
)
{ after(grammarAccess.getLiteralTypeAccess().getREALEnumLiteralDeclaration_2()); }
)

    |(
{ before(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); }
(	'ptCharacter' 
)
{ after(grammarAccess.getLiteralTypeAccess().getCHAREnumLiteralDeclaration_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__RoomModel__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__0__Impl
	rule__RoomModel__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getRoomModelKeyword_0()); }

	'RoomModel' 

{ after(grammarAccess.getRoomModelAccess().getRoomModelKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RoomModel__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__1__Impl
	rule__RoomModel__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getNameAssignment_1()); }
(rule__RoomModel__NameAssignment_1)
{ after(grammarAccess.getRoomModelAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RoomModel__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__2__Impl
	rule__RoomModel__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getDocuAssignment_2()); }
(rule__RoomModel__DocuAssignment_2)?
{ after(grammarAccess.getRoomModelAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RoomModel__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__3__Impl
	rule__RoomModel__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getRoomModelAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RoomModel__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__4__Impl
	rule__RoomModel__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getImportsAssignment_4()); }
(rule__RoomModel__ImportsAssignment_4)*
{ after(grammarAccess.getRoomModelAccess().getImportsAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RoomModel__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__5__Impl
	rule__RoomModel__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getAlternatives_5()); }
(rule__RoomModel__Alternatives_5)*
{ after(grammarAccess.getRoomModelAccess().getAlternatives_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RoomModel__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RoomModel__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getRightCurlyBracketKeyword_6()); }

	'}' 

{ after(grammarAccess.getRoomModelAccess().getRightCurlyBracketKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__VarDecl__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VarDecl__Group__0__Impl
	rule__VarDecl__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__VarDecl__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVarDeclAccess().getNameAssignment_0()); }
(rule__VarDecl__NameAssignment_0)
{ after(grammarAccess.getVarDeclAccess().getNameAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VarDecl__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VarDecl__Group__1__Impl
	rule__VarDecl__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__VarDecl__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVarDeclAccess().getColonKeyword_1()); }

	':' 

{ after(grammarAccess.getVarDeclAccess().getColonKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__VarDecl__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__VarDecl__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__VarDecl__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVarDeclAccess().getRefTypeAssignment_2()); }
(rule__VarDecl__RefTypeAssignment_2)
{ after(grammarAccess.getVarDeclAccess().getRefTypeAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__RefableType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefableType__Group__0__Impl
	rule__RefableType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefableType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefableTypeAccess().getTypeAssignment_0()); }
(rule__RefableType__TypeAssignment_0)
{ after(grammarAccess.getRefableTypeAccess().getTypeAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefableType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefableType__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefableType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefableTypeAccess().getRefAssignment_1()); }
(rule__RefableType__RefAssignment_1)?
{ after(grammarAccess.getRefableTypeAccess().getRefAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PrimitiveType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__0__Impl
	rule__PrimitiveType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getPrimitiveTypeKeyword_0()); }

	'PrimitiveType' 

{ after(grammarAccess.getPrimitiveTypeAccess().getPrimitiveTypeKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__1__Impl
	rule__PrimitiveType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getNameAssignment_1()); }
(rule__PrimitiveType__NameAssignment_1)
{ after(grammarAccess.getPrimitiveTypeAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__2__Impl
	rule__PrimitiveType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__3__Impl
	rule__PrimitiveType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getTypeAssignment_3()); }
(rule__PrimitiveType__TypeAssignment_3)
{ after(grammarAccess.getPrimitiveTypeAccess().getTypeAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__4__Impl
	rule__PrimitiveType__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getHyphenMinusGreaterThanSignKeyword_4()); }

	'->' 

{ after(grammarAccess.getPrimitiveTypeAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__5__Impl
	rule__PrimitiveType__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getTargetNameAssignment_5()); }
(rule__PrimitiveType__TargetNameAssignment_5)
{ after(grammarAccess.getPrimitiveTypeAccess().getTargetNameAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__6__Impl
	rule__PrimitiveType__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getGroup_6()); }
(rule__PrimitiveType__Group_6__0)?
{ after(grammarAccess.getPrimitiveTypeAccess().getGroup_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__7__Impl
	rule__PrimitiveType__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getDefaultKeyword_7()); }

	'default' 

{ after(grammarAccess.getPrimitiveTypeAccess().getDefaultKeyword_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__8__Impl
	rule__PrimitiveType__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralAssignment_8()); }
(rule__PrimitiveType__DefaultValueLiteralAssignment_8)
{ after(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralAssignment_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group__9__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getDocuAssignment_9()); }
(rule__PrimitiveType__DocuAssignment_9)?
{ after(grammarAccess.getPrimitiveTypeAccess().getDocuAssignment_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}






















rule__PrimitiveType__Group_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group_6__0__Impl
	rule__PrimitiveType__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getLeftParenthesisKeyword_6_0()); }

	'(' 

{ after(grammarAccess.getPrimitiveTypeAccess().getLeftParenthesisKeyword_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group_6__1__Impl
	rule__PrimitiveType__Group_6__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getCastNameAssignment_6_1()); }
(rule__PrimitiveType__CastNameAssignment_6_1)
{ after(grammarAccess.getPrimitiveTypeAccess().getCastNameAssignment_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PrimitiveType__Group_6__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PrimitiveType__Group_6__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__Group_6__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getRightParenthesisKeyword_6_2()); }

	')' 

{ after(grammarAccess.getPrimitiveTypeAccess().getRightParenthesisKeyword_6_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__EnumerationType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__0__Impl
	rule__EnumerationType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getEnumerationKeyword_0()); }

	'Enumeration' 

{ after(grammarAccess.getEnumerationTypeAccess().getEnumerationKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__1__Impl
	rule__EnumerationType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getNameAssignment_1()); }
(rule__EnumerationType__NameAssignment_1)
{ after(grammarAccess.getEnumerationTypeAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__2__Impl
	rule__EnumerationType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getDocuAssignment_2()); }
(rule__EnumerationType__DocuAssignment_2)?
{ after(grammarAccess.getEnumerationTypeAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__3__Impl
	rule__EnumerationType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getGroup_3()); }
(rule__EnumerationType__Group_3__0)?
{ after(grammarAccess.getEnumerationTypeAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__4__Impl
	rule__EnumerationType__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getLeftCurlyBracketKeyword_4()); }

	'{' 

{ after(grammarAccess.getEnumerationTypeAccess().getLeftCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__5__Impl
	rule__EnumerationType__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getGroup_5()); }
(rule__EnumerationType__Group_5__0)?
{ after(grammarAccess.getEnumerationTypeAccess().getGroup_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getRightCurlyBracketKeyword_6()); }

	'}' 

{ after(grammarAccess.getEnumerationTypeAccess().getRightCurlyBracketKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__EnumerationType__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group_3__0__Impl
	rule__EnumerationType__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getOfKeyword_3_0()); }

	'of' 

{ after(grammarAccess.getEnumerationTypeAccess().getOfKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypeAssignment_3_1()); }
(rule__EnumerationType__PrimitiveTypeAssignment_3_1)
{ after(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypeAssignment_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EnumerationType__Group_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group_5__0__Impl
	rule__EnumerationType__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getLiteralsAssignment_5_0()); }
(rule__EnumerationType__LiteralsAssignment_5_0)
{ after(grammarAccess.getEnumerationTypeAccess().getLiteralsAssignment_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getGroup_5_1()); }
(rule__EnumerationType__Group_5_1__0)*
{ after(grammarAccess.getEnumerationTypeAccess().getGroup_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EnumerationType__Group_5_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group_5_1__0__Impl
	rule__EnumerationType__Group_5_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group_5_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getCommaKeyword_5_1_0()); }

	',' 

{ after(grammarAccess.getEnumerationTypeAccess().getCommaKeyword_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumerationType__Group_5_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumerationType__Group_5_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__Group_5_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getLiteralsAssignment_5_1_1()); }
(rule__EnumerationType__LiteralsAssignment_5_1_1)
{ after(grammarAccess.getEnumerationTypeAccess().getLiteralsAssignment_5_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EnumLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumLiteral__Group__0__Impl
	rule__EnumLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumLiteralAccess().getNameAssignment_0()); }
(rule__EnumLiteral__NameAssignment_0)
{ after(grammarAccess.getEnumLiteralAccess().getNameAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumLiteralAccess().getGroup_1()); }
(rule__EnumLiteral__Group_1__0)?
{ after(grammarAccess.getEnumLiteralAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__EnumLiteral__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumLiteral__Group_1__0__Impl
	rule__EnumLiteral__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumLiteralAccess().getEqualsSignKeyword_1_0()); }

	'=' 

{ after(grammarAccess.getEnumLiteralAccess().getEqualsSignKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumLiteral__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumLiteral__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumLiteralAccess().getLiteralAssignment_1_1()); }
(rule__EnumLiteral__LiteralAssignment_1_1)
{ after(grammarAccess.getEnumLiteralAccess().getLiteralAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ExternalType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group__0__Impl
	rule__ExternalType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getExternalTypeKeyword_0()); }

	'ExternalType' 

{ after(grammarAccess.getExternalTypeAccess().getExternalTypeKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group__1__Impl
	rule__ExternalType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getNameAssignment_1()); }
(rule__ExternalType__NameAssignment_1)
{ after(grammarAccess.getExternalTypeAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group__2__Impl
	rule__ExternalType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getHyphenMinusGreaterThanSignKeyword_2()); }

	'->' 

{ after(grammarAccess.getExternalTypeAccess().getHyphenMinusGreaterThanSignKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalType__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group__3__Impl
	rule__ExternalType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getTargetNameAssignment_3()); }
(rule__ExternalType__TargetNameAssignment_3)
{ after(grammarAccess.getExternalTypeAccess().getTargetNameAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalType__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group__4__Impl
	rule__ExternalType__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getGroup_4()); }
(rule__ExternalType__Group_4__0)?
{ after(grammarAccess.getExternalTypeAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalType__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getDocuAssignment_5()); }
(rule__ExternalType__DocuAssignment_5)?
{ after(grammarAccess.getExternalTypeAccess().getDocuAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__ExternalType__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group_4__0__Impl
	rule__ExternalType__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getDefaultKeyword_4_0()); }

	'default' 

{ after(grammarAccess.getExternalTypeAccess().getDefaultKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalType__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalType__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralAssignment_4_1()); }
(rule__ExternalType__DefaultValueLiteralAssignment_4_1)
{ after(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__DataClass__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__0__Impl
	rule__DataClass__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getDataClassKeyword_0()); }

	'DataClass' 

{ after(grammarAccess.getDataClassAccess().getDataClassKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__1__Impl
	rule__DataClass__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getNameAssignment_1()); }
(rule__DataClass__NameAssignment_1)
{ after(grammarAccess.getDataClassAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__2__Impl
	rule__DataClass__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getDocuAssignment_2()); }
(rule__DataClass__DocuAssignment_2)?
{ after(grammarAccess.getDataClassAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__3__Impl
	rule__DataClass__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getGroup_3()); }
(rule__DataClass__Group_3__0)?
{ after(grammarAccess.getDataClassAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__4__Impl
	rule__DataClass__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getLeftCurlyBracketKeyword_4()); }

	'{' 

{ after(grammarAccess.getDataClassAccess().getLeftCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__5__Impl
	rule__DataClass__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getAnnotationsAssignment_5()); }
(rule__DataClass__AnnotationsAssignment_5)*
{ after(grammarAccess.getDataClassAccess().getAnnotationsAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__6__Impl
	rule__DataClass__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getGroup_6()); }
(rule__DataClass__Group_6__0)?
{ after(grammarAccess.getDataClassAccess().getGroup_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__7__Impl
	rule__DataClass__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getGroup_7()); }
(rule__DataClass__Group_7__0)?
{ after(grammarAccess.getDataClassAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__8__Impl
	rule__DataClass__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getGroup_8()); }
(rule__DataClass__Group_8__0)?
{ after(grammarAccess.getDataClassAccess().getGroup_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__9__Impl
	rule__DataClass__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getAlternatives_9()); }
(rule__DataClass__Alternatives_9)*
{ after(grammarAccess.getDataClassAccess().getAlternatives_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group__10__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getRightCurlyBracketKeyword_10()); }

	'}' 

{ after(grammarAccess.getDataClassAccess().getRightCurlyBracketKeyword_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}
























rule__DataClass__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_3__0__Impl
	rule__DataClass__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getExtendsKeyword_3_0()); }

	'extends' 

{ after(grammarAccess.getDataClassAccess().getExtendsKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getBaseAssignment_3_1()); }
(rule__DataClass__BaseAssignment_3_1)
{ after(grammarAccess.getDataClassAccess().getBaseAssignment_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__DataClass__Group_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_6__0__Impl
	rule__DataClass__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUsercode1Keyword_6_0()); }

	'usercode1' 

{ after(grammarAccess.getDataClassAccess().getUsercode1Keyword_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUserCode1Assignment_6_1()); }
(rule__DataClass__UserCode1Assignment_6_1)
{ after(grammarAccess.getDataClassAccess().getUserCode1Assignment_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__DataClass__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_7__0__Impl
	rule__DataClass__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUsercode2Keyword_7_0()); }

	'usercode2' 

{ after(grammarAccess.getDataClassAccess().getUsercode2Keyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUserCode2Assignment_7_1()); }
(rule__DataClass__UserCode2Assignment_7_1)
{ after(grammarAccess.getDataClassAccess().getUserCode2Assignment_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__DataClass__Group_8__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_8__0__Impl
	rule__DataClass__Group_8__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_8__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUsercode3Keyword_8_0()); }

	'usercode3' 

{ after(grammarAccess.getDataClassAccess().getUsercode3Keyword_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DataClass__Group_8__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DataClass__Group_8__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__Group_8__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUserCode3Assignment_8_1()); }
(rule__DataClass__UserCode3Assignment_8_1)
{ after(grammarAccess.getDataClassAccess().getUserCode3Assignment_8_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Attribute__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__0__Impl
	rule__Attribute__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getAttributeKeyword_0()); }

	'Attribute' 

{ after(grammarAccess.getAttributeAccess().getAttributeKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__1__Impl
	rule__Attribute__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getNameAssignment_1()); }
(rule__Attribute__NameAssignment_1)
{ after(grammarAccess.getAttributeAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__2__Impl
	rule__Attribute__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getGroup_2()); }
(rule__Attribute__Group_2__0)?
{ after(grammarAccess.getAttributeAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__3__Impl
	rule__Attribute__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getColonKeyword_3()); }

	':' 

{ after(grammarAccess.getAttributeAccess().getColonKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__4__Impl
	rule__Attribute__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getTypeAssignment_4()); }
(rule__Attribute__TypeAssignment_4)
{ after(grammarAccess.getAttributeAccess().getTypeAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__5__Impl
	rule__Attribute__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getGroup_5()); }
(rule__Attribute__Group_5__0)?
{ after(grammarAccess.getAttributeAccess().getGroup_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getDocuAssignment_6()); }
(rule__Attribute__DocuAssignment_6)?
{ after(grammarAccess.getAttributeAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__Attribute__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group_2__0__Impl
	rule__Attribute__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getLeftSquareBracketKeyword_2_0()); }

	'[' 

{ after(grammarAccess.getAttributeAccess().getLeftSquareBracketKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group_2__1__Impl
	rule__Attribute__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getSizeAssignment_2_1()); }
(rule__Attribute__SizeAssignment_2_1)
{ after(grammarAccess.getAttributeAccess().getSizeAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group_2__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group_2__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group_2__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getRightSquareBracketKeyword_2_2()); }

	']' 

{ after(grammarAccess.getAttributeAccess().getRightSquareBracketKeyword_2_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__Attribute__Group_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group_5__0__Impl
	rule__Attribute__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getEqualsSignKeyword_5_0()); }

	'=' 

{ after(grammarAccess.getAttributeAccess().getEqualsSignKeyword_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Attribute__Group_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Attribute__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__Group_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getDefaultValueLiteralAssignment_5_1()); }
(rule__Attribute__DefaultValueLiteralAssignment_5_1)
{ after(grammarAccess.getAttributeAccess().getDefaultValueLiteralAssignment_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__StandardOperation__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__0__Impl
	rule__StandardOperation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getOverrideAssignment_0()); }
(rule__StandardOperation__OverrideAssignment_0)?
{ after(grammarAccess.getStandardOperationAccess().getOverrideAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__1__Impl
	rule__StandardOperation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getOperationKeyword_1()); }

	'Operation' 

{ after(grammarAccess.getStandardOperationAccess().getOperationKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__2__Impl
	rule__StandardOperation__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getNameAssignment_2()); }
(rule__StandardOperation__NameAssignment_2)
{ after(grammarAccess.getStandardOperationAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__3__Impl
	rule__StandardOperation__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getLeftParenthesisKeyword_3()); }

	'(' 

{ after(grammarAccess.getStandardOperationAccess().getLeftParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__4__Impl
	rule__StandardOperation__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getGroup_4()); }
(rule__StandardOperation__Group_4__0)?
{ after(grammarAccess.getStandardOperationAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__5__Impl
	rule__StandardOperation__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getRightParenthesisKeyword_5()); }

	')' 

{ after(grammarAccess.getStandardOperationAccess().getRightParenthesisKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__6__Impl
	rule__StandardOperation__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getGroup_6()); }
(rule__StandardOperation__Group_6__0)?
{ after(grammarAccess.getStandardOperationAccess().getGroup_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__7__Impl
	rule__StandardOperation__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getDocuAssignment_7()); }
(rule__StandardOperation__DocuAssignment_7)?
{ after(grammarAccess.getStandardOperationAccess().getDocuAssignment_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group__8__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getDetailCodeAssignment_8()); }
(rule__StandardOperation__DetailCodeAssignment_8)
{ after(grammarAccess.getStandardOperationAccess().getDetailCodeAssignment_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}




















rule__StandardOperation__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group_4__0__Impl
	rule__StandardOperation__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getArgumentsAssignment_4_0()); }
(rule__StandardOperation__ArgumentsAssignment_4_0)
{ after(grammarAccess.getStandardOperationAccess().getArgumentsAssignment_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getGroup_4_1()); }
(rule__StandardOperation__Group_4_1__0)*
{ after(grammarAccess.getStandardOperationAccess().getGroup_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__StandardOperation__Group_4_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group_4_1__0__Impl
	rule__StandardOperation__Group_4_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group_4_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getCommaKeyword_4_1_0()); }

	',' 

{ after(grammarAccess.getStandardOperationAccess().getCommaKeyword_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group_4_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group_4_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group_4_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getArgumentsAssignment_4_1_1()); }
(rule__StandardOperation__ArgumentsAssignment_4_1_1)
{ after(grammarAccess.getStandardOperationAccess().getArgumentsAssignment_4_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__StandardOperation__Group_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group_6__0__Impl
	rule__StandardOperation__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getColonKeyword_6_0()); }

	':' 

{ after(grammarAccess.getStandardOperationAccess().getColonKeyword_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StandardOperation__Group_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StandardOperation__Group_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__Group_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getAlternatives_6_1()); }
(rule__StandardOperation__Alternatives_6_1)
{ after(grammarAccess.getStandardOperationAccess().getAlternatives_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PortOperation__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__0__Impl
	rule__PortOperation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getOperationKeyword_0()); }

	'Operation' 

{ after(grammarAccess.getPortOperationAccess().getOperationKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__1__Impl
	rule__PortOperation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getNameAssignment_1()); }
(rule__PortOperation__NameAssignment_1)
{ after(grammarAccess.getPortOperationAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__2__Impl
	rule__PortOperation__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getLeftParenthesisKeyword_2()); }

	'(' 

{ after(grammarAccess.getPortOperationAccess().getLeftParenthesisKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__3__Impl
	rule__PortOperation__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getGroup_3()); }
(rule__PortOperation__Group_3__0)?
{ after(grammarAccess.getPortOperationAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__4__Impl
	rule__PortOperation__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getRightParenthesisKeyword_4()); }

	')' 

{ after(grammarAccess.getPortOperationAccess().getRightParenthesisKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__5__Impl
	rule__PortOperation__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getAlternatives_5()); }
(rule__PortOperation__Alternatives_5)?
{ after(grammarAccess.getPortOperationAccess().getAlternatives_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__6__Impl
	rule__PortOperation__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getDocuAssignment_6()); }
(rule__PortOperation__DocuAssignment_6)?
{ after(grammarAccess.getPortOperationAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getDetailCodeAssignment_7()); }
(rule__PortOperation__DetailCodeAssignment_7)
{ after(grammarAccess.getPortOperationAccess().getDetailCodeAssignment_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


















rule__PortOperation__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_3__0__Impl
	rule__PortOperation__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getArgumentsAssignment_3_0()); }
(rule__PortOperation__ArgumentsAssignment_3_0)
{ after(grammarAccess.getPortOperationAccess().getArgumentsAssignment_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getGroup_3_1()); }
(rule__PortOperation__Group_3_1__0)*
{ after(grammarAccess.getPortOperationAccess().getGroup_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PortOperation__Group_3_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_3_1__0__Impl
	rule__PortOperation__Group_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_3_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getCommaKeyword_3_1_0()); }

	',' 

{ after(grammarAccess.getPortOperationAccess().getCommaKeyword_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group_3_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_3_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getArgumentsAssignment_3_1_1()); }
(rule__PortOperation__ArgumentsAssignment_3_1_1)
{ after(grammarAccess.getPortOperationAccess().getArgumentsAssignment_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PortOperation__Group_5_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_5_0__0__Impl
	rule__PortOperation__Group_5_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_5_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getColonKeyword_5_0_0()); }

	':' 

{ after(grammarAccess.getPortOperationAccess().getColonKeyword_5_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group_5_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_5_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_5_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getAlternatives_5_0_1()); }
(rule__PortOperation__Alternatives_5_0_1)
{ after(grammarAccess.getPortOperationAccess().getAlternatives_5_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__PortOperation__Group_5_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_5_1__0__Impl
	rule__PortOperation__Group_5_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_5_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getSendsKeyword_5_1_0()); }

	'sends' 

{ after(grammarAccess.getPortOperationAccess().getSendsKeyword_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortOperation__Group_5_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortOperation__Group_5_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__Group_5_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getSendsMsgAssignment_5_1_1()); }
(rule__PortOperation__SendsMsgAssignment_5_1_1)
{ after(grammarAccess.getPortOperationAccess().getSendsMsgAssignment_5_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ClassStructor__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ClassStructor__Group__0__Impl
	rule__ClassStructor__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassStructor__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getClassStructorAccess().getNameAssignment_0()); }
(rule__ClassStructor__NameAssignment_0)
{ after(grammarAccess.getClassStructorAccess().getNameAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ClassStructor__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ClassStructor__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ClassStructor__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getClassStructorAccess().getDetailCodeAssignment_1()); }
(rule__ClassStructor__DetailCodeAssignment_1)
{ after(grammarAccess.getClassStructorAccess().getDetailCodeAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ProtocolClass__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__0__Impl
	rule__ProtocolClass__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getCommTypeAssignment_0()); }
(rule__ProtocolClass__CommTypeAssignment_0)?
{ after(grammarAccess.getProtocolClassAccess().getCommTypeAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__1__Impl
	rule__ProtocolClass__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getProtocolClassKeyword_1()); }

	'ProtocolClass' 

{ after(grammarAccess.getProtocolClassAccess().getProtocolClassKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__2__Impl
	rule__ProtocolClass__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getNameAssignment_2()); }
(rule__ProtocolClass__NameAssignment_2)
{ after(grammarAccess.getProtocolClassAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__3__Impl
	rule__ProtocolClass__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getDocuAssignment_3()); }
(rule__ProtocolClass__DocuAssignment_3)?
{ after(grammarAccess.getProtocolClassAccess().getDocuAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__4__Impl
	rule__ProtocolClass__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_4()); }
(rule__ProtocolClass__Group_4__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__5__Impl
	rule__ProtocolClass__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_5()); }

	'{' 

{ after(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__6__Impl
	rule__ProtocolClass__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getAnnotationsAssignment_6()); }
(rule__ProtocolClass__AnnotationsAssignment_6)*
{ after(grammarAccess.getProtocolClassAccess().getAnnotationsAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__7__Impl
	rule__ProtocolClass__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_7()); }
(rule__ProtocolClass__Group_7__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__8__Impl
	rule__ProtocolClass__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_8()); }
(rule__ProtocolClass__Group_8__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__9__Impl
	rule__ProtocolClass__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_9()); }
(rule__ProtocolClass__Group_9__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__10__Impl
	rule__ProtocolClass__Group__11
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_10()); }
(rule__ProtocolClass__Group_10__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__11
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__11__Impl
	rule__ProtocolClass__Group__12
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__11__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_11()); }
(rule__ProtocolClass__Group_11__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_11()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__12
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__12__Impl
	rule__ProtocolClass__Group__13
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__12__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_12()); }
(rule__ProtocolClass__Group_12__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_12()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__13
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__13__Impl
	rule__ProtocolClass__Group__14
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__13__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getGroup_13()); }
(rule__ProtocolClass__Group_13__0)?
{ after(grammarAccess.getProtocolClassAccess().getGroup_13()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__14
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__14__Impl
	rule__ProtocolClass__Group__15
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__14__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getSemanticsAssignment_14()); }
(rule__ProtocolClass__SemanticsAssignment_14)?
{ after(grammarAccess.getProtocolClassAccess().getSemanticsAssignment_14()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group__15
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group__15__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group__15__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_15()); }

	'}' 

{ after(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_15()); }
)

;
finally {
	restoreStackSize(stackSize);
}


































rule__ProtocolClass__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_4__0__Impl
	rule__ProtocolClass__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getExtendsKeyword_4_0()); }

	'extends' 

{ after(grammarAccess.getProtocolClassAccess().getExtendsKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getBaseAssignment_4_1()); }
(rule__ProtocolClass__BaseAssignment_4_1)
{ after(grammarAccess.getProtocolClassAccess().getBaseAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ProtocolClass__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_7__0__Impl
	rule__ProtocolClass__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUsercode1Keyword_7_0()); }

	'usercode1' 

{ after(grammarAccess.getProtocolClassAccess().getUsercode1Keyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUserCode1Assignment_7_1()); }
(rule__ProtocolClass__UserCode1Assignment_7_1)
{ after(grammarAccess.getProtocolClassAccess().getUserCode1Assignment_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ProtocolClass__Group_8__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_8__0__Impl
	rule__ProtocolClass__Group_8__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_8__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUsercode2Keyword_8_0()); }

	'usercode2' 

{ after(grammarAccess.getProtocolClassAccess().getUsercode2Keyword_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_8__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_8__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_8__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUserCode2Assignment_8_1()); }
(rule__ProtocolClass__UserCode2Assignment_8_1)
{ after(grammarAccess.getProtocolClassAccess().getUserCode2Assignment_8_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ProtocolClass__Group_9__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_9__0__Impl
	rule__ProtocolClass__Group_9__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_9__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUsercode3Keyword_9_0()); }

	'usercode3' 

{ after(grammarAccess.getProtocolClassAccess().getUsercode3Keyword_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_9__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_9__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_9__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUserCode3Assignment_9_1()); }
(rule__ProtocolClass__UserCode3Assignment_9_1)
{ after(grammarAccess.getProtocolClassAccess().getUserCode3Assignment_9_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ProtocolClass__Group_10__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_10__0__Impl
	rule__ProtocolClass__Group_10__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_10__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getIncomingKeyword_10_0()); }

	'incoming' 

{ after(grammarAccess.getProtocolClassAccess().getIncomingKeyword_10_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_10__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_10__1__Impl
	rule__ProtocolClass__Group_10__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_10__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_10_1()); }

	'{' 

{ after(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_10_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_10__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_10__2__Impl
	rule__ProtocolClass__Group_10__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_10__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getIncomingMessagesAssignment_10_2()); }
(rule__ProtocolClass__IncomingMessagesAssignment_10_2)*
{ after(grammarAccess.getProtocolClassAccess().getIncomingMessagesAssignment_10_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_10__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_10__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_10__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_10_3()); }

	'}' 

{ after(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_10_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ProtocolClass__Group_11__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_11__0__Impl
	rule__ProtocolClass__Group_11__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_11__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getOutgoingKeyword_11_0()); }

	'outgoing' 

{ after(grammarAccess.getProtocolClassAccess().getOutgoingKeyword_11_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_11__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_11__1__Impl
	rule__ProtocolClass__Group_11__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_11__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_11_1()); }

	'{' 

{ after(grammarAccess.getProtocolClassAccess().getLeftCurlyBracketKeyword_11_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_11__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_11__2__Impl
	rule__ProtocolClass__Group_11__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_11__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getOutgoingMessagesAssignment_11_2()); }
(rule__ProtocolClass__OutgoingMessagesAssignment_11_2)*
{ after(grammarAccess.getProtocolClassAccess().getOutgoingMessagesAssignment_11_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_11__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_11__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_11__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_11_3()); }

	'}' 

{ after(grammarAccess.getProtocolClassAccess().getRightCurlyBracketKeyword_11_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ProtocolClass__Group_12__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_12__0__Impl
	rule__ProtocolClass__Group_12__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_12__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getRegularKeyword_12_0()); }

	'regular' 

{ after(grammarAccess.getProtocolClassAccess().getRegularKeyword_12_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_12__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_12__1__Impl
	rule__ProtocolClass__Group_12__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_12__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getPortClassKeyword_12_1()); }

	'PortClass' 

{ after(grammarAccess.getProtocolClassAccess().getPortClassKeyword_12_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_12__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_12__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_12__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getRegularAssignment_12_2()); }
(rule__ProtocolClass__RegularAssignment_12_2)
{ after(grammarAccess.getProtocolClassAccess().getRegularAssignment_12_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ProtocolClass__Group_13__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_13__0__Impl
	rule__ProtocolClass__Group_13__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_13__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getConjugatedKeyword_13_0()); }

	'conjugated' 

{ after(grammarAccess.getProtocolClassAccess().getConjugatedKeyword_13_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_13__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_13__1__Impl
	rule__ProtocolClass__Group_13__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_13__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getPortClassKeyword_13_1()); }

	'PortClass' 

{ after(grammarAccess.getProtocolClassAccess().getPortClassKeyword_13_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolClass__Group_13__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolClass__Group_13__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__Group_13__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getConjugatedAssignment_13_2()); }
(rule__ProtocolClass__ConjugatedAssignment_13_2)
{ after(grammarAccess.getProtocolClassAccess().getConjugatedAssignment_13_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__CompoundProtocolClass__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__0__Impl
	rule__CompoundProtocolClass__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getCompoundProtocolClassKeyword_0()); }

	'CompoundProtocolClass' 

{ after(grammarAccess.getCompoundProtocolClassAccess().getCompoundProtocolClassKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CompoundProtocolClass__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__1__Impl
	rule__CompoundProtocolClass__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getNameAssignment_1()); }
(rule__CompoundProtocolClass__NameAssignment_1)
{ after(grammarAccess.getCompoundProtocolClassAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CompoundProtocolClass__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__2__Impl
	rule__CompoundProtocolClass__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getDocuAssignment_2()); }
(rule__CompoundProtocolClass__DocuAssignment_2)?
{ after(grammarAccess.getCompoundProtocolClassAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CompoundProtocolClass__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__3__Impl
	rule__CompoundProtocolClass__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getCompoundProtocolClassAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CompoundProtocolClass__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__4__Impl
	rule__CompoundProtocolClass__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAssignment_4()); }
(rule__CompoundProtocolClass__AnnotationsAssignment_4)*
{ after(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CompoundProtocolClass__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__5__Impl
	rule__CompoundProtocolClass__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsAssignment_5()); }
(rule__CompoundProtocolClass__SubProtocolsAssignment_5)*
{ after(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CompoundProtocolClass__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CompoundProtocolClass__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getRightCurlyBracketKeyword_6()); }

	'}' 

{ after(grammarAccess.getCompoundProtocolClassAccess().getRightCurlyBracketKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__SubProtocol__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubProtocol__Group__0__Impl
	rule__SubProtocol__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubProtocol__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubProtocolAccess().getSubProtocolKeyword_0()); }

	'SubProtocol' 

{ after(grammarAccess.getSubProtocolAccess().getSubProtocolKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubProtocol__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubProtocol__Group__1__Impl
	rule__SubProtocol__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SubProtocol__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubProtocolAccess().getNameAssignment_1()); }
(rule__SubProtocol__NameAssignment_1)
{ after(grammarAccess.getSubProtocolAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubProtocol__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubProtocol__Group__2__Impl
	rule__SubProtocol__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__SubProtocol__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubProtocol__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubProtocol__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubProtocolAccess().getProtocolAssignment_3()); }
(rule__SubProtocol__ProtocolAssignment_3)
{ after(grammarAccess.getSubProtocolAccess().getProtocolAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__Message__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__0__Impl
	rule__Message__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getPrivAssignment_0()); }
(rule__Message__PrivAssignment_0)?
{ after(grammarAccess.getMessageAccess().getPrivAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Message__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__1__Impl
	rule__Message__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getMessageKeyword_1()); }

	'Message' 

{ after(grammarAccess.getMessageAccess().getMessageKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Message__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__2__Impl
	rule__Message__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getNameAssignment_2()); }
(rule__Message__NameAssignment_2)
{ after(grammarAccess.getMessageAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Message__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__3__Impl
	rule__Message__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); }

	'(' 

{ after(grammarAccess.getMessageAccess().getLeftParenthesisKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Message__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__4__Impl
	rule__Message__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getDataAssignment_4()); }
(rule__Message__DataAssignment_4)?
{ after(grammarAccess.getMessageAccess().getDataAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Message__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__5__Impl
	rule__Message__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); }

	')' 

{ after(grammarAccess.getMessageAccess().getRightParenthesisKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Message__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Message__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Message__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getDocuAssignment_6()); }
(rule__Message__DocuAssignment_6)?
{ after(grammarAccess.getMessageAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__PortClass__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group__0__Impl
	rule__PortClass__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getPortClassAction_0()); }
(

)
{ after(grammarAccess.getPortClassAccess().getPortClassAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortClass__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group__1__Impl
	rule__PortClass__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getLeftCurlyBracketKeyword_1()); }

	'{' 

{ after(grammarAccess.getPortClassAccess().getLeftCurlyBracketKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortClass__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group__2__Impl
	rule__PortClass__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getGroup_2()); }
(rule__PortClass__Group_2__0)?
{ after(grammarAccess.getPortClassAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortClass__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group__3__Impl
	rule__PortClass__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getAlternatives_3()); }
(rule__PortClass__Alternatives_3)*
{ after(grammarAccess.getPortClassAccess().getAlternatives_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortClass__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getRightCurlyBracketKeyword_4()); }

	'}' 

{ after(grammarAccess.getPortClassAccess().getRightCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__PortClass__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group_2__0__Impl
	rule__PortClass__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getUsercodeKeyword_2_0()); }

	'usercode' 

{ after(grammarAccess.getPortClassAccess().getUsercodeKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__PortClass__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__PortClass__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getUserCodeAssignment_2_1()); }
(rule__PortClass__UserCodeAssignment_2_1)
{ after(grammarAccess.getPortClassAccess().getUserCodeAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__InMessageHandler__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InMessageHandler__Group__0__Impl
	rule__InMessageHandler__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InMessageHandler__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInMessageHandlerAccess().getHandleKeyword_0()); }

	'handle' 

{ after(grammarAccess.getInMessageHandlerAccess().getHandleKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InMessageHandler__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InMessageHandler__Group__1__Impl
	rule__InMessageHandler__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__InMessageHandler__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInMessageHandlerAccess().getIncomingKeyword_1()); }

	'incoming' 

{ after(grammarAccess.getInMessageHandlerAccess().getIncomingKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InMessageHandler__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InMessageHandler__Group__2__Impl
	rule__InMessageHandler__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__InMessageHandler__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInMessageHandlerAccess().getMsgAssignment_2()); }
(rule__InMessageHandler__MsgAssignment_2)
{ after(grammarAccess.getInMessageHandlerAccess().getMsgAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InMessageHandler__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InMessageHandler__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InMessageHandler__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInMessageHandlerAccess().getDetailCodeAssignment_3()); }
(rule__InMessageHandler__DetailCodeAssignment_3)
{ after(grammarAccess.getInMessageHandlerAccess().getDetailCodeAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__OutMessageHandler__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutMessageHandler__Group__0__Impl
	rule__OutMessageHandler__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__OutMessageHandler__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getHandleKeyword_0()); }

	'handle' 

{ after(grammarAccess.getOutMessageHandlerAccess().getHandleKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutMessageHandler__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutMessageHandler__Group__1__Impl
	rule__OutMessageHandler__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__OutMessageHandler__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getOutgoingKeyword_1()); }

	'outgoing' 

{ after(grammarAccess.getOutMessageHandlerAccess().getOutgoingKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutMessageHandler__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutMessageHandler__Group__2__Impl
	rule__OutMessageHandler__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__OutMessageHandler__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getMsgAssignment_2()); }
(rule__OutMessageHandler__MsgAssignment_2)
{ after(grammarAccess.getOutMessageHandlerAccess().getMsgAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutMessageHandler__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutMessageHandler__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__OutMessageHandler__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getDetailCodeAssignment_3()); }
(rule__OutMessageHandler__DetailCodeAssignment_3)
{ after(grammarAccess.getOutMessageHandlerAccess().getDetailCodeAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ActorClass__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__0__Impl
	rule__ActorClass__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUnorderedGroup_0()); }
(rule__ActorClass__UnorderedGroup_0)
{ after(grammarAccess.getActorClassAccess().getUnorderedGroup_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__1__Impl
	rule__ActorClass__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getActorClassKeyword_1()); }

	'ActorClass' 

{ after(grammarAccess.getActorClassAccess().getActorClassKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__2__Impl
	rule__ActorClass__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getNameAssignment_2()); }
(rule__ActorClass__NameAssignment_2)
{ after(grammarAccess.getActorClassAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__3__Impl
	rule__ActorClass__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getDocuAssignment_3()); }
(rule__ActorClass__DocuAssignment_3)?
{ after(grammarAccess.getActorClassAccess().getDocuAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__4__Impl
	rule__ActorClass__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_4()); }
(rule__ActorClass__Group_4__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__5__Impl
	rule__ActorClass__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_5()); }

	'{' 

{ after(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__6__Impl
	rule__ActorClass__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAnnotationsAssignment_6()); }
(rule__ActorClass__AnnotationsAssignment_6)*
{ after(grammarAccess.getActorClassAccess().getAnnotationsAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__7__Impl
	rule__ActorClass__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_7()); }
(rule__ActorClass__Group_7__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__8__Impl
	rule__ActorClass__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_8()); }
(rule__ActorClass__Group_8__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__9__Impl
	rule__ActorClass__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_9()); }
(rule__ActorClass__Group_9__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group__10__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_10()); }

	'}' 

{ after(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}
























rule__ActorClass__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_4__0__Impl
	rule__ActorClass__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getExtendsKeyword_4_0()); }

	'extends' 

{ after(grammarAccess.getActorClassAccess().getExtendsKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBaseAssignment_4_1()); }
(rule__ActorClass__BaseAssignment_4_1)
{ after(grammarAccess.getActorClassAccess().getBaseAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ActorClass__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_7__0__Impl
	rule__ActorClass__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getInterfaceKeyword_7_0()); }

	'Interface' 

{ after(grammarAccess.getActorClassAccess().getInterfaceKeyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_7__1__Impl
	rule__ActorClass__Group_7__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_7_1()); }

	'{' 

{ after(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_7__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_7__2__Impl
	rule__ActorClass__Group_7__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_7__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAlternatives_7_2()); }
(rule__ActorClass__Alternatives_7_2)*
{ after(grammarAccess.getActorClassAccess().getAlternatives_7_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_7__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_7__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_7__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_7_3()); }

	'}' 

{ after(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_7_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ActorClass__Group_8__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__0__Impl
	rule__ActorClass__Group_8__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getStructureKeyword_8_0()); }

	'Structure' 

{ after(grammarAccess.getActorClassAccess().getStructureKeyword_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__1__Impl
	rule__ActorClass__Group_8__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getStructureDocuAssignment_8_1()); }
(rule__ActorClass__StructureDocuAssignment_8_1)?
{ after(grammarAccess.getActorClassAccess().getStructureDocuAssignment_8_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__2__Impl
	rule__ActorClass__Group_8__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_8_2()); }

	'{' 

{ after(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_8_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__3__Impl
	rule__ActorClass__Group_8__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_8_3()); }
(rule__ActorClass__Group_8_3__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_8_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__4__Impl
	rule__ActorClass__Group_8__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_8_4()); }
(rule__ActorClass__Group_8_4__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_8_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__5__Impl
	rule__ActorClass__Group_8__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getGroup_8_5()); }
(rule__ActorClass__Group_8_5__0)?
{ after(grammarAccess.getActorClassAccess().getGroup_8_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__6__Impl
	rule__ActorClass__Group_8__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAlternatives_8_6()); }
(rule__ActorClass__Alternatives_8_6)*
{ after(grammarAccess.getActorClassAccess().getAlternatives_8_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_8_7()); }

	'}' 

{ after(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_8_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


















rule__ActorClass__Group_8_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8_3__0__Impl
	rule__ActorClass__Group_8_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUsercode1Keyword_8_3_0()); }

	'usercode1' 

{ after(grammarAccess.getActorClassAccess().getUsercode1Keyword_8_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUserCode1Assignment_8_3_1()); }
(rule__ActorClass__UserCode1Assignment_8_3_1)
{ after(grammarAccess.getActorClassAccess().getUserCode1Assignment_8_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ActorClass__Group_8_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8_4__0__Impl
	rule__ActorClass__Group_8_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUsercode2Keyword_8_4_0()); }

	'usercode2' 

{ after(grammarAccess.getActorClassAccess().getUsercode2Keyword_8_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUserCode2Assignment_8_4_1()); }
(rule__ActorClass__UserCode2Assignment_8_4_1)
{ after(grammarAccess.getActorClassAccess().getUserCode2Assignment_8_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ActorClass__Group_8_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8_5__0__Impl
	rule__ActorClass__Group_8_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUsercode3Keyword_8_5_0()); }

	'usercode3' 

{ after(grammarAccess.getActorClassAccess().getUsercode3Keyword_8_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_8_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_8_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_8_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUserCode3Assignment_8_5_1()); }
(rule__ActorClass__UserCode3Assignment_8_5_1)
{ after(grammarAccess.getActorClassAccess().getUserCode3Assignment_8_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ActorClass__Group_9__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__0__Impl
	rule__ActorClass__Group_9__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBehaviorKeyword_9_0()); }

	'Behavior' 

{ after(grammarAccess.getActorClassAccess().getBehaviorKeyword_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_9__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__1__Impl
	rule__ActorClass__Group_9__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBehaviorDocuAssignment_9_1()); }
(rule__ActorClass__BehaviorDocuAssignment_9_1)?
{ after(grammarAccess.getActorClassAccess().getBehaviorDocuAssignment_9_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_9__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__2__Impl
	rule__ActorClass__Group_9__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_9_2()); }

	'{' 

{ after(grammarAccess.getActorClassAccess().getLeftCurlyBracketKeyword_9_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_9__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__3__Impl
	rule__ActorClass__Group_9__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAssignment_9_3()); }
(rule__ActorClass__BehaviorAnnotationsAssignment_9_3)*
{ after(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAssignment_9_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_9__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__4__Impl
	rule__ActorClass__Group_9__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAlternatives_9_4()); }
(rule__ActorClass__Alternatives_9_4)*
{ after(grammarAccess.getActorClassAccess().getAlternatives_9_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_9__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__5__Impl
	rule__ActorClass__Group_9__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getStateMachineAssignment_9_5()); }
(rule__ActorClass__StateMachineAssignment_9_5)?
{ after(grammarAccess.getActorClassAccess().getStateMachineAssignment_9_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__Group_9__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__Group_9__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__Group_9__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_9_6()); }

	'}' 

{ after(grammarAccess.getActorClassAccess().getRightCurlyBracketKeyword_9_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__Port__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__0__Impl
	rule__Port__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getConjugatedAssignment_0()); }
(rule__Port__ConjugatedAssignment_0)?
{ after(grammarAccess.getPortAccess().getConjugatedAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Port__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__1__Impl
	rule__Port__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getPortKeyword_1()); }

	'Port' 

{ after(grammarAccess.getPortAccess().getPortKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Port__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__2__Impl
	rule__Port__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getNameAssignment_2()); }
(rule__Port__NameAssignment_2)
{ after(grammarAccess.getPortAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Port__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__3__Impl
	rule__Port__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getMultiplicityAssignment_3()); }
(rule__Port__MultiplicityAssignment_3)?
{ after(grammarAccess.getPortAccess().getMultiplicityAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Port__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__4__Impl
	rule__Port__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getColonKeyword_4()); }

	':' 

{ after(grammarAccess.getPortAccess().getColonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Port__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__5__Impl
	rule__Port__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getProtocolAssignment_5()); }
(rule__Port__ProtocolAssignment_5)
{ after(grammarAccess.getPortAccess().getProtocolAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Port__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Port__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Port__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getDocuAssignment_6()); }
(rule__Port__DocuAssignment_6)?
{ after(grammarAccess.getPortAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__ExternalPort__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalPort__Group__0__Impl
	rule__ExternalPort__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalPort__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalPortAccess().getExternalKeyword_0()); }

	'external' 

{ after(grammarAccess.getExternalPortAccess().getExternalKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalPort__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalPort__Group__1__Impl
	rule__ExternalPort__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalPort__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalPortAccess().getPortKeyword_1()); }

	'Port' 

{ after(grammarAccess.getExternalPortAccess().getPortKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExternalPort__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExternalPort__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalPort__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalPortAccess().getInterfacePortAssignment_2()); }
(rule__ExternalPort__InterfacePortAssignment_2)
{ after(grammarAccess.getExternalPortAccess().getInterfacePortAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__SAP__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SAP__Group__0__Impl
	rule__SAP__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SAP__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSAPAccess().getSAPKeyword_0()); }

	'SAP' 

{ after(grammarAccess.getSAPAccess().getSAPKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SAP__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SAP__Group__1__Impl
	rule__SAP__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SAP__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSAPAccess().getNameAssignment_1()); }
(rule__SAP__NameAssignment_1)
{ after(grammarAccess.getSAPAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SAP__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SAP__Group__2__Impl
	rule__SAP__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__SAP__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SAP__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SAP__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSAPAccess().getProtocolAssignment_3()); }
(rule__SAP__ProtocolAssignment_3)
{ after(grammarAccess.getSAPAccess().getProtocolAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__SPP__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPP__Group__0__Impl
	rule__SPP__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SPP__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPAccess().getSPPKeyword_0()); }

	'SPP' 

{ after(grammarAccess.getSPPAccess().getSPPKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SPP__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPP__Group__1__Impl
	rule__SPP__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SPP__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPAccess().getNameAssignment_1()); }
(rule__SPP__NameAssignment_1)
{ after(grammarAccess.getSPPAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SPP__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPP__Group__2__Impl
	rule__SPP__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__SPP__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPP__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SPP__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPAccess().getProtocolAssignment_3()); }
(rule__SPP__ProtocolAssignment_3)
{ after(grammarAccess.getSPPAccess().getProtocolAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__ServiceImplementation__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ServiceImplementation__Group__0__Impl
	rule__ServiceImplementation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ServiceImplementation__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getServiceImplementationAccess().getServiceImplementationKeyword_0()); }

	'ServiceImplementation' 

{ after(grammarAccess.getServiceImplementationAccess().getServiceImplementationKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ServiceImplementation__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ServiceImplementation__Group__1__Impl
	rule__ServiceImplementation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ServiceImplementation__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getServiceImplementationAccess().getOfKeyword_1()); }

	'of' 

{ after(grammarAccess.getServiceImplementationAccess().getOfKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ServiceImplementation__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ServiceImplementation__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ServiceImplementation__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getServiceImplementationAccess().getSppAssignment_2()); }
(rule__ServiceImplementation__SppAssignment_2)
{ after(grammarAccess.getServiceImplementationAccess().getSppAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__LogicalSystem__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__0__Impl
	rule__LogicalSystem__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getLogicalSystemKeyword_0()); }

	'LogicalSystem' 

{ after(grammarAccess.getLogicalSystemAccess().getLogicalSystemKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalSystem__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__1__Impl
	rule__LogicalSystem__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getNameAssignment_1()); }
(rule__LogicalSystem__NameAssignment_1)
{ after(grammarAccess.getLogicalSystemAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalSystem__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__2__Impl
	rule__LogicalSystem__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getDocuAssignment_2()); }
(rule__LogicalSystem__DocuAssignment_2)?
{ after(grammarAccess.getLogicalSystemAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalSystem__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__3__Impl
	rule__LogicalSystem__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getLogicalSystemAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalSystem__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__4__Impl
	rule__LogicalSystem__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getAnnotationsAssignment_4()); }
(rule__LogicalSystem__AnnotationsAssignment_4)*
{ after(grammarAccess.getLogicalSystemAccess().getAnnotationsAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalSystem__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__5__Impl
	rule__LogicalSystem__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getAlternatives_5()); }
(rule__LogicalSystem__Alternatives_5)*
{ after(grammarAccess.getLogicalSystemAccess().getAlternatives_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalSystem__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalSystem__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getRightCurlyBracketKeyword_6()); }

	'}' 

{ after(grammarAccess.getLogicalSystemAccess().getRightCurlyBracketKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__SubSystemRef__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemRef__Group__0__Impl
	rule__SubSystemRef__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getSubSystemRefKeyword_0()); }

	'SubSystemRef' 

{ after(grammarAccess.getSubSystemRefAccess().getSubSystemRefKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemRef__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemRef__Group__1__Impl
	rule__SubSystemRef__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getNameAssignment_1()); }
(rule__SubSystemRef__NameAssignment_1)
{ after(grammarAccess.getSubSystemRefAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemRef__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemRef__Group__2__Impl
	rule__SubSystemRef__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemRef__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemRef__Group__3__Impl
	rule__SubSystemRef__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getTypeAssignment_3()); }
(rule__SubSystemRef__TypeAssignment_3)
{ after(grammarAccess.getSubSystemRefAccess().getTypeAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemRef__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemRef__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getDocuAssignment_4()); }
(rule__SubSystemRef__DocuAssignment_4)?
{ after(grammarAccess.getSubSystemRefAccess().getDocuAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__SubSystemClass__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__0__Impl
	rule__SubSystemClass__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getSubSystemClassKeyword_0()); }

	'SubSystemClass' 

{ after(grammarAccess.getSubSystemClassAccess().getSubSystemClassKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__1__Impl
	rule__SubSystemClass__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getNameAssignment_1()); }
(rule__SubSystemClass__NameAssignment_1)
{ after(grammarAccess.getSubSystemClassAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__2__Impl
	rule__SubSystemClass__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getDocuAssignment_2()); }
(rule__SubSystemClass__DocuAssignment_2)?
{ after(grammarAccess.getSubSystemClassAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__3__Impl
	rule__SubSystemClass__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getSubSystemClassAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__4__Impl
	rule__SubSystemClass__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getAnnotationsAssignment_4()); }
(rule__SubSystemClass__AnnotationsAssignment_4)*
{ after(grammarAccess.getSubSystemClassAccess().getAnnotationsAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__5__Impl
	rule__SubSystemClass__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getGroup_5()); }
(rule__SubSystemClass__Group_5__0)?
{ after(grammarAccess.getSubSystemClassAccess().getGroup_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__6__Impl
	rule__SubSystemClass__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getGroup_6()); }
(rule__SubSystemClass__Group_6__0)?
{ after(grammarAccess.getSubSystemClassAccess().getGroup_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__7__Impl
	rule__SubSystemClass__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getGroup_7()); }
(rule__SubSystemClass__Group_7__0)?
{ after(grammarAccess.getSubSystemClassAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__8__Impl
	rule__SubSystemClass__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getAlternatives_8()); }
(rule__SubSystemClass__Alternatives_8)*
{ after(grammarAccess.getSubSystemClassAccess().getAlternatives_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group__9__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getRightCurlyBracketKeyword_9()); }

	'}' 

{ after(grammarAccess.getSubSystemClassAccess().getRightCurlyBracketKeyword_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}






















rule__SubSystemClass__Group_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group_5__0__Impl
	rule__SubSystemClass__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUsercode1Keyword_5_0()); }

	'usercode1' 

{ after(grammarAccess.getSubSystemClassAccess().getUsercode1Keyword_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUserCode1Assignment_5_1()); }
(rule__SubSystemClass__UserCode1Assignment_5_1)
{ after(grammarAccess.getSubSystemClassAccess().getUserCode1Assignment_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SubSystemClass__Group_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group_6__0__Impl
	rule__SubSystemClass__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUsercode2Keyword_6_0()); }

	'usercode2' 

{ after(grammarAccess.getSubSystemClassAccess().getUsercode2Keyword_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUserCode2Assignment_6_1()); }
(rule__SubSystemClass__UserCode2Assignment_6_1)
{ after(grammarAccess.getSubSystemClassAccess().getUserCode2Assignment_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SubSystemClass__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group_7__0__Impl
	rule__SubSystemClass__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUsercode3Keyword_7_0()); }

	'usercode3' 

{ after(grammarAccess.getSubSystemClassAccess().getUsercode3Keyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubSystemClass__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubSystemClass__Group_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUserCode3Assignment_7_1()); }
(rule__SubSystemClass__UserCode3Assignment_7_1)
{ after(grammarAccess.getSubSystemClassAccess().getUserCode3Assignment_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__LogicalThread__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalThread__Group__0__Impl
	rule__LogicalThread__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalThread__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalThreadAccess().getLogicalThreadKeyword_0()); }

	'LogicalThread' 

{ after(grammarAccess.getLogicalThreadAccess().getLogicalThreadKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LogicalThread__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LogicalThread__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalThread__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalThreadAccess().getNameAssignment_1()); }
(rule__LogicalThread__NameAssignment_1)
{ after(grammarAccess.getLogicalThreadAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ActorInstanceMapping__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group__0__Impl
	rule__ActorInstanceMapping__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingKeyword_0()); }

	'ActorInstanceMapping' 

{ after(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorInstanceMapping__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group__1__Impl
	rule__ActorInstanceMapping__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getPathAssignment_1()); }
(rule__ActorInstanceMapping__PathAssignment_1)
{ after(grammarAccess.getActorInstanceMappingAccess().getPathAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorInstanceMapping__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group__2__Impl
	rule__ActorInstanceMapping__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getHyphenMinusGreaterThanSignKeyword_2()); }

	'->' 

{ after(grammarAccess.getActorInstanceMappingAccess().getHyphenMinusGreaterThanSignKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorInstanceMapping__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group__3__Impl
	rule__ActorInstanceMapping__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getThreadAssignment_3()); }
(rule__ActorInstanceMapping__ThreadAssignment_3)
{ after(grammarAccess.getActorInstanceMappingAccess().getThreadAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorInstanceMapping__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getGroup_4()); }
(rule__ActorInstanceMapping__Group_4__0)?
{ after(grammarAccess.getActorInstanceMappingAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__ActorInstanceMapping__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group_4__0__Impl
	rule__ActorInstanceMapping__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getLeftCurlyBracketKeyword_4_0()); }

	'{' 

{ after(grammarAccess.getActorInstanceMappingAccess().getLeftCurlyBracketKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorInstanceMapping__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group_4__1__Impl
	rule__ActorInstanceMapping__Group_4__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsAssignment_4_1()); }
(rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1)*
{ after(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorInstanceMapping__Group_4__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorInstanceMapping__Group_4__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__Group_4__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getRightCurlyBracketKeyword_4_2()); }

	'}' 

{ after(grammarAccess.getActorInstanceMappingAccess().getRightCurlyBracketKeyword_4_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__RefPath__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefPath__Group__0__Impl
	rule__RefPath__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefPath__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefPathAccess().getRefsAssignment_0()); }
(rule__RefPath__RefsAssignment_0)
{ after(grammarAccess.getRefPathAccess().getRefsAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefPath__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefPath__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefPath__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefPathAccess().getGroup_1()); }
(rule__RefPath__Group_1__0)*
{ after(grammarAccess.getRefPathAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefPath__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefPath__Group_1__0__Impl
	rule__RefPath__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefPath__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefPathAccess().getSolidusKeyword_1_0()); }

	'/' 

{ after(grammarAccess.getRefPathAccess().getSolidusKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefPath__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefPath__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefPath__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefPathAccess().getRefsAssignment_1_1()); }
(rule__RefPath__RefsAssignment_1_1)
{ after(grammarAccess.getRefPathAccess().getRefsAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefSegment__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefSegment__Group__0__Impl
	rule__RefSegment__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefSegment__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSegmentAccess().getRefAssignment_0()); }
(rule__RefSegment__RefAssignment_0)
{ after(grammarAccess.getRefSegmentAccess().getRefAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefSegment__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefSegment__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefSegment__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSegmentAccess().getGroup_1()); }
(rule__RefSegment__Group_1__0)?
{ after(grammarAccess.getRefSegmentAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefSegment__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefSegment__Group_1__0__Impl
	rule__RefSegment__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefSegment__Group_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSegmentAccess().getColonKeyword_1_0()); }

	':' 

{ after(grammarAccess.getRefSegmentAccess().getColonKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefSegment__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefSegment__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefSegment__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSegmentAccess().getIdxAssignment_1_1()); }
(rule__RefSegment__IdxAssignment_1_1)
{ after(grammarAccess.getRefSegmentAccess().getIdxAssignment_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Binding__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Binding__Group__0__Impl
	rule__Binding__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Binding__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingAccess().getBindingKeyword_0()); }

	'Binding' 

{ after(grammarAccess.getBindingAccess().getBindingKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Binding__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Binding__Group__1__Impl
	rule__Binding__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Binding__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingAccess().getEndpoint1Assignment_1()); }
(rule__Binding__Endpoint1Assignment_1)
{ after(grammarAccess.getBindingAccess().getEndpoint1Assignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Binding__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Binding__Group__2__Impl
	rule__Binding__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Binding__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingAccess().getAndKeyword_2()); }

	'and' 

{ after(grammarAccess.getBindingAccess().getAndKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Binding__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Binding__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Binding__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingAccess().getEndpoint2Assignment_3()); }
(rule__Binding__Endpoint2Assignment_3)
{ after(grammarAccess.getBindingAccess().getEndpoint2Assignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__BindingEndPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group__0__Impl
	rule__BindingEndPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getGroup_0()); }
(rule__BindingEndPoint__Group_0__0)?
{ after(grammarAccess.getBindingEndPointAccess().getGroup_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BindingEndPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group__1__Impl
	rule__BindingEndPoint__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getPortAssignment_1()); }
(rule__BindingEndPoint__PortAssignment_1)
{ after(grammarAccess.getBindingEndPointAccess().getPortAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BindingEndPoint__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getGroup_2()); }
(rule__BindingEndPoint__Group_2__0)?
{ after(grammarAccess.getBindingEndPointAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__BindingEndPoint__Group_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group_0__0__Impl
	rule__BindingEndPoint__Group_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getActorRefAssignment_0_0()); }
(rule__BindingEndPoint__ActorRefAssignment_0_0)
{ after(grammarAccess.getBindingEndPointAccess().getActorRefAssignment_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BindingEndPoint__Group_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getFullStopKeyword_0_1()); }

	'.' 

{ after(grammarAccess.getBindingEndPointAccess().getFullStopKeyword_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__BindingEndPoint__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group_2__0__Impl
	rule__BindingEndPoint__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getSubKeyword_2_0()); }

	'sub' 

{ after(grammarAccess.getBindingEndPointAccess().getSubKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BindingEndPoint__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BindingEndPoint__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getSubAssignment_2_1()); }
(rule__BindingEndPoint__SubAssignment_2_1)
{ after(grammarAccess.getBindingEndPointAccess().getSubAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__LayerConnection__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LayerConnection__Group__0__Impl
	rule__LayerConnection__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__LayerConnection__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLayerConnectionAccess().getLayerConnectionKeyword_0()); }

	'LayerConnection' 

{ after(grammarAccess.getLayerConnectionAccess().getLayerConnectionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LayerConnection__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LayerConnection__Group__1__Impl
	rule__LayerConnection__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__LayerConnection__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLayerConnectionAccess().getFromAssignment_1()); }
(rule__LayerConnection__FromAssignment_1)
{ after(grammarAccess.getLayerConnectionAccess().getFromAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LayerConnection__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LayerConnection__Group__2__Impl
	rule__LayerConnection__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__LayerConnection__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLayerConnectionAccess().getSatisfied_byKeyword_2()); }

	'satisfied_by' 

{ after(grammarAccess.getLayerConnectionAccess().getSatisfied_byKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__LayerConnection__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__LayerConnection__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__LayerConnection__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLayerConnectionAccess().getToAssignment_3()); }
(rule__LayerConnection__ToAssignment_3)
{ after(grammarAccess.getLayerConnectionAccess().getToAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__RefSAPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefSAPoint__Group__0__Impl
	rule__RefSAPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefSAPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSAPointAccess().getRefKeyword_0()); }

	'ref' 

{ after(grammarAccess.getRefSAPointAccess().getRefKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefSAPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefSAPoint__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefSAPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSAPointAccess().getRefAssignment_1()); }
(rule__RefSAPoint__RefAssignment_1)
{ after(grammarAccess.getRefSAPointAccess().getRefAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RelaySAPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelaySAPoint__Group__0__Impl
	rule__RelaySAPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RelaySAPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelaySAPointAccess().getRelay_sapKeyword_0()); }

	'relay_sap' 

{ after(grammarAccess.getRelaySAPointAccess().getRelay_sapKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RelaySAPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RelaySAPoint__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RelaySAPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelaySAPointAccess().getRelayAssignment_1()); }
(rule__RelaySAPoint__RelayAssignment_1)
{ after(grammarAccess.getRelaySAPointAccess().getRelayAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SPPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPPoint__Group__0__Impl
	rule__SPPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SPPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPointAccess().getRefAssignment_0()); }
(rule__SPPoint__RefAssignment_0)
{ after(grammarAccess.getSPPointAccess().getRefAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SPPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPPoint__Group__1__Impl
	rule__SPPoint__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SPPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPointAccess().getFullStopKeyword_1()); }

	'.' 

{ after(grammarAccess.getSPPointAccess().getFullStopKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SPPoint__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SPPoint__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SPPoint__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPointAccess().getServiceAssignment_2()); }
(rule__SPPoint__ServiceAssignment_2)
{ after(grammarAccess.getSPPointAccess().getServiceAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ActorRef__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__0__Impl
	rule__ActorRef__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getRefTypeAssignment_0()); }
(rule__ActorRef__RefTypeAssignment_0)?
{ after(grammarAccess.getActorRefAccess().getRefTypeAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorRef__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__1__Impl
	rule__ActorRef__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getActorRefKeyword_1()); }

	'ActorRef' 

{ after(grammarAccess.getActorRefAccess().getActorRefKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorRef__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__2__Impl
	rule__ActorRef__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getNameAssignment_2()); }
(rule__ActorRef__NameAssignment_2)
{ after(grammarAccess.getActorRefAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorRef__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__3__Impl
	rule__ActorRef__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getMultiplicityAssignment_3()); }
(rule__ActorRef__MultiplicityAssignment_3)?
{ after(grammarAccess.getActorRefAccess().getMultiplicityAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorRef__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__4__Impl
	rule__ActorRef__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getColonKeyword_4()); }

	':' 

{ after(grammarAccess.getActorRefAccess().getColonKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorRef__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__5__Impl
	rule__ActorRef__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getTypeAssignment_5()); }
(rule__ActorRef__TypeAssignment_5)
{ after(grammarAccess.getActorRefAccess().getTypeAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ActorRef__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorRef__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getDocuAssignment_6()); }
(rule__ActorRef__DocuAssignment_6)?
{ after(grammarAccess.getActorRefAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__MULTIPLICITY__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MULTIPLICITY__Group__0__Impl
	rule__MULTIPLICITY__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MULTIPLICITY__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMULTIPLICITYAccess().getLeftSquareBracketKeyword_0()); }

	'[' 

{ after(grammarAccess.getMULTIPLICITYAccess().getLeftSquareBracketKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MULTIPLICITY__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MULTIPLICITY__Group__1__Impl
	rule__MULTIPLICITY__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MULTIPLICITY__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMULTIPLICITYAccess().getAlternatives_1()); }
(rule__MULTIPLICITY__Alternatives_1)
{ after(grammarAccess.getMULTIPLICITYAccess().getAlternatives_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MULTIPLICITY__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MULTIPLICITY__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MULTIPLICITY__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMULTIPLICITYAccess().getRightSquareBracketKeyword_2()); }

	']' 

{ after(grammarAccess.getMULTIPLICITYAccess().getRightSquareBracketKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__StateGraph__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateGraph__Group__0__Impl
	rule__StateGraph__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); }
(

)
{ after(grammarAccess.getStateGraphAccess().getStateGraphAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateGraph__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateGraph__Group__1__Impl
	rule__StateGraph__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); }

	'{' 

{ after(grammarAccess.getStateGraphAccess().getLeftCurlyBracketKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateGraph__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateGraph__Group__2__Impl
	rule__StateGraph__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getAlternatives_2()); }
(rule__StateGraph__Alternatives_2)*
{ after(grammarAccess.getStateGraphAccess().getAlternatives_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateGraph__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateGraph__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); }

	'}' 

{ after(grammarAccess.getStateGraphAccess().getRightCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__StateMachine__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateMachine__Group__0__Impl
	rule__StateMachine__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); }
(

)
{ after(grammarAccess.getStateMachineAccess().getStateGraphAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateMachine__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateMachine__Group__1__Impl
	rule__StateMachine__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); }

	'StateMachine' 

{ after(grammarAccess.getStateMachineAccess().getStateMachineKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateMachine__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateMachine__Group__2__Impl
	rule__StateMachine__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	'{' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__StateMachine__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateMachine__Group__3__Impl
	rule__StateMachine__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getAlternatives_3()); }
(rule__StateMachine__Alternatives_3)*
{ after(grammarAccess.getStateMachineAccess().getAlternatives_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateMachine__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StateMachine__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); }

	'}' 

{ after(grammarAccess.getStateMachineAccess().getRightCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__SimpleState__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group__0__Impl
	rule__SimpleState__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); }

	'State' 

{ after(grammarAccess.getSimpleStateAccess().getStateKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group__1__Impl
	rule__SimpleState__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getNameAssignment_1()); }
(rule__SimpleState__NameAssignment_1)
{ after(grammarAccess.getSimpleStateAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group__2__Impl
	rule__SimpleState__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getDocuAssignment_2()); }
(rule__SimpleState__DocuAssignment_2)?
{ after(grammarAccess.getSimpleStateAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getGroup_3()); }
(rule__SimpleState__Group_3__0)?
{ after(grammarAccess.getSimpleStateAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__SimpleState__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3__0__Impl
	rule__SimpleState__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); }

	'{' 

{ after(grammarAccess.getSimpleStateAccess().getLeftCurlyBracketKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3__1__Impl
	rule__SimpleState__Group_3__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getGroup_3_1()); }
(rule__SimpleState__Group_3_1__0)?
{ after(grammarAccess.getSimpleStateAccess().getGroup_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3__2__Impl
	rule__SimpleState__Group_3__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getGroup_3_2()); }
(rule__SimpleState__Group_3_2__0)?
{ after(grammarAccess.getSimpleStateAccess().getGroup_3_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3__3__Impl
	rule__SimpleState__Group_3__4
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getGroup_3_3()); }
(rule__SimpleState__Group_3_3__0)?
{ after(grammarAccess.getSimpleStateAccess().getGroup_3_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3__4__Impl
	rule__SimpleState__Group_3__5
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getGroup_3_4()); }
(rule__SimpleState__Group_3_4__0)?
{ after(grammarAccess.getSimpleStateAccess().getGroup_3_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3__5__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); }

	'}' 

{ after(grammarAccess.getSimpleStateAccess().getRightCurlyBracketKeyword_3_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}














rule__SimpleState__Group_3_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_1__0__Impl
	rule__SimpleState__Group_3_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); }

	'entry' 

{ after(grammarAccess.getSimpleStateAccess().getEntryKeyword_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getEntryCodeAssignment_3_1_1()); }
(rule__SimpleState__EntryCodeAssignment_3_1_1)
{ after(grammarAccess.getSimpleStateAccess().getEntryCodeAssignment_3_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SimpleState__Group_3_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_2__0__Impl
	rule__SimpleState__Group_3_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); }

	'exit' 

{ after(grammarAccess.getSimpleStateAccess().getExitKeyword_3_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getExitCodeAssignment_3_2_1()); }
(rule__SimpleState__ExitCodeAssignment_3_2_1)
{ after(grammarAccess.getSimpleStateAccess().getExitCodeAssignment_3_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SimpleState__Group_3_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_3__0__Impl
	rule__SimpleState__Group_3_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); }

	'do' 

{ after(grammarAccess.getSimpleStateAccess().getDoKeyword_3_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getDoCodeAssignment_3_3_1()); }
(rule__SimpleState__DoCodeAssignment_3_3_1)
{ after(grammarAccess.getSimpleStateAccess().getDoCodeAssignment_3_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SimpleState__Group_3_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_4__0__Impl
	rule__SimpleState__Group_3_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); }

	'subgraph' 

{ after(grammarAccess.getSimpleStateAccess().getSubgraphKeyword_3_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleState__Group_3_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleState__Group_3_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__Group_3_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getSubgraphAssignment_3_4_1()); }
(rule__SimpleState__SubgraphAssignment_3_4_1)
{ after(grammarAccess.getSimpleStateAccess().getSubgraphAssignment_3_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefinedState__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__0__Impl
	rule__RefinedState__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); }

	'RefinedState' 

{ after(grammarAccess.getRefinedStateAccess().getRefinedStateKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__1__Impl
	rule__RefinedState__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getTargetAssignment_1()); }
(rule__RefinedState__TargetAssignment_1)
{ after(grammarAccess.getRefinedStateAccess().getTargetAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__2__Impl
	rule__RefinedState__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getDocuAssignment_2()); }
(rule__RefinedState__DocuAssignment_2)?
{ after(grammarAccess.getRefinedStateAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__3__Impl
	rule__RefinedState__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getRefinedStateAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__4__Impl
	rule__RefinedState__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getGroup_4()); }
(rule__RefinedState__Group_4__0)?
{ after(grammarAccess.getRefinedStateAccess().getGroup_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__5__Impl
	rule__RefinedState__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getGroup_5()); }
(rule__RefinedState__Group_5__0)?
{ after(grammarAccess.getRefinedStateAccess().getGroup_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__6__Impl
	rule__RefinedState__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getGroup_6()); }
(rule__RefinedState__Group_6__0)?
{ after(grammarAccess.getRefinedStateAccess().getGroup_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__7__Impl
	rule__RefinedState__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getGroup_7()); }
(rule__RefinedState__Group_7__0)?
{ after(grammarAccess.getRefinedStateAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group__8__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); }

	'}' 

{ after(grammarAccess.getRefinedStateAccess().getRightCurlyBracketKeyword_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}




















rule__RefinedState__Group_4__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_4__0__Impl
	rule__RefinedState__Group_4__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_4__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); }

	'entry' 

{ after(grammarAccess.getRefinedStateAccess().getEntryKeyword_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group_4__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_4__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_4__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getEntryCodeAssignment_4_1()); }
(rule__RefinedState__EntryCodeAssignment_4_1)
{ after(grammarAccess.getRefinedStateAccess().getEntryCodeAssignment_4_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefinedState__Group_5__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_5__0__Impl
	rule__RefinedState__Group_5__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_5__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); }

	'exit' 

{ after(grammarAccess.getRefinedStateAccess().getExitKeyword_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group_5__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_5__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_5__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getExitCodeAssignment_5_1()); }
(rule__RefinedState__ExitCodeAssignment_5_1)
{ after(grammarAccess.getRefinedStateAccess().getExitCodeAssignment_5_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefinedState__Group_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_6__0__Impl
	rule__RefinedState__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); }

	'do' 

{ after(grammarAccess.getRefinedStateAccess().getDoKeyword_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getDoCodeAssignment_6_1()); }
(rule__RefinedState__DoCodeAssignment_6_1)
{ after(grammarAccess.getRefinedStateAccess().getDoCodeAssignment_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefinedState__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_7__0__Impl
	rule__RefinedState__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); }

	'subgraph' 

{ after(grammarAccess.getRefinedStateAccess().getSubgraphKeyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedState__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedState__Group_7__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getSubgraphAssignment_7_1()); }
(rule__RefinedState__SubgraphAssignment_7_1)
{ after(grammarAccess.getRefinedStateAccess().getSubgraphAssignment_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__DetailCode__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DetailCode__Group__0__Impl
	rule__DetailCode__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DetailCode__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0()); }
(

)
{ after(grammarAccess.getDetailCodeAccess().getDetailCodeAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DetailCode__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DetailCode__Group__1__Impl
	rule__DetailCode__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DetailCode__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDetailCodeAccess().getUsedAssignment_1()); }
(rule__DetailCode__UsedAssignment_1)
{ after(grammarAccess.getDetailCodeAccess().getUsedAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DetailCode__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DetailCode__Group__2__Impl
	rule__DetailCode__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DetailCode__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDetailCodeAccess().getLinesAssignment_2()); }
(rule__DetailCode__LinesAssignment_2)*
{ after(grammarAccess.getDetailCodeAccess().getLinesAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DetailCode__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DetailCode__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DetailCode__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_3()); }

	'}' 

{ after(grammarAccess.getDetailCodeAccess().getRightCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__TransitionPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TransitionPoint__Group__0__Impl
	rule__TransitionPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionPointAccess().getHandlerAssignment_0()); }
(rule__TransitionPoint__HandlerAssignment_0)?
{ after(grammarAccess.getTransitionPointAccess().getHandlerAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TransitionPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TransitionPoint__Group__1__Impl
	rule__TransitionPoint__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); }

	'TransitionPoint' 

{ after(grammarAccess.getTransitionPointAccess().getTransitionPointKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TransitionPoint__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TransitionPoint__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionPoint__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionPointAccess().getNameAssignment_2()); }
(rule__TransitionPoint__NameAssignment_2)
{ after(grammarAccess.getTransitionPointAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__EntryPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EntryPoint__Group__0__Impl
	rule__EntryPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EntryPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); }

	'EntryPoint' 

{ after(grammarAccess.getEntryPointAccess().getEntryPointKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EntryPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EntryPoint__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EntryPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEntryPointAccess().getNameAssignment_1()); }
(rule__EntryPoint__NameAssignment_1)
{ after(grammarAccess.getEntryPointAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ExitPoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExitPoint__Group__0__Impl
	rule__ExitPoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ExitPoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); }

	'ExitPoint' 

{ after(grammarAccess.getExitPointAccess().getExitPointKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ExitPoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ExitPoint__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ExitPoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExitPointAccess().getNameAssignment_1()); }
(rule__ExitPoint__NameAssignment_1)
{ after(grammarAccess.getExitPointAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ChoicePoint__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ChoicePoint__Group__0__Impl
	rule__ChoicePoint__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicePoint__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); }

	'ChoicePoint' 

{ after(grammarAccess.getChoicePointAccess().getChoicePointKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ChoicePoint__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ChoicePoint__Group__1__Impl
	rule__ChoicePoint__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicePoint__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicePointAccess().getNameAssignment_1()); }
(rule__ChoicePoint__NameAssignment_1)
{ after(grammarAccess.getChoicePointAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ChoicePoint__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ChoicePoint__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicePoint__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicePointAccess().getDocuAssignment_2()); }
(rule__ChoicePoint__DocuAssignment_2)?
{ after(grammarAccess.getChoicePointAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__InitialTransition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__0__Impl
	rule__InitialTransition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); }

	'Transition' 

{ after(grammarAccess.getInitialTransitionAccess().getTransitionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__1__Impl
	rule__InitialTransition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getNameAssignment_1()); }
(rule__InitialTransition__NameAssignment_1)?
{ after(grammarAccess.getInitialTransitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__2__Impl
	rule__InitialTransition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__3__Impl
	rule__InitialTransition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); }

	'initial' 

{ after(grammarAccess.getInitialTransitionAccess().getInitialKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__4__Impl
	rule__InitialTransition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }

	'->' 

{ after(grammarAccess.getInitialTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__5__Impl
	rule__InitialTransition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getToAssignment_5()); }
(rule__InitialTransition__ToAssignment_5)
{ after(grammarAccess.getInitialTransitionAccess().getToAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__6__Impl
	rule__InitialTransition__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getDocuAssignment_6()); }
(rule__InitialTransition__DocuAssignment_6)?
{ after(grammarAccess.getInitialTransitionAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getGroup_7()); }
(rule__InitialTransition__Group_7__0)?
{ after(grammarAccess.getInitialTransitionAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


















rule__InitialTransition__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group_7__0__Impl
	rule__InitialTransition__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); }

	'{' 

{ after(grammarAccess.getInitialTransitionAccess().getLeftCurlyBracketKeyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group_7__1__Impl
	rule__InitialTransition__Group_7__2
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getGroup_7_1()); }
(rule__InitialTransition__Group_7_1__0)?
{ after(grammarAccess.getInitialTransitionAccess().getGroup_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group_7__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group_7__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group_7__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); }

	'}' 

{ after(grammarAccess.getInitialTransitionAccess().getRightCurlyBracketKeyword_7_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__InitialTransition__Group_7_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group_7_1__0__Impl
	rule__InitialTransition__Group_7_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group_7_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); }

	'action' 

{ after(grammarAccess.getInitialTransitionAccess().getActionKeyword_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InitialTransition__Group_7_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InitialTransition__Group_7_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__Group_7_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getActionAssignment_7_1_1()); }
(rule__InitialTransition__ActionAssignment_7_1_1)
{ after(grammarAccess.getInitialTransitionAccess().getActionAssignment_7_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ContinuationTransition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__0__Impl
	rule__ContinuationTransition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); }

	'Transition' 

{ after(grammarAccess.getContinuationTransitionAccess().getTransitionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__1__Impl
	rule__ContinuationTransition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getNameAssignment_1()); }
(rule__ContinuationTransition__NameAssignment_1)?
{ after(grammarAccess.getContinuationTransitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__2__Impl
	rule__ContinuationTransition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__3__Impl
	rule__ContinuationTransition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getFromAssignment_3()); }
(rule__ContinuationTransition__FromAssignment_3)
{ after(grammarAccess.getContinuationTransitionAccess().getFromAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__4__Impl
	rule__ContinuationTransition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }

	'->' 

{ after(grammarAccess.getContinuationTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__5__Impl
	rule__ContinuationTransition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getToAssignment_5()); }
(rule__ContinuationTransition__ToAssignment_5)
{ after(grammarAccess.getContinuationTransitionAccess().getToAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__6__Impl
	rule__ContinuationTransition__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getDocuAssignment_6()); }
(rule__ContinuationTransition__DocuAssignment_6)?
{ after(grammarAccess.getContinuationTransitionAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getGroup_7()); }
(rule__ContinuationTransition__Group_7__0)?
{ after(grammarAccess.getContinuationTransitionAccess().getGroup_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


















rule__ContinuationTransition__Group_7__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group_7__0__Impl
	rule__ContinuationTransition__Group_7__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group_7__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); }

	'{' 

{ after(grammarAccess.getContinuationTransitionAccess().getLeftCurlyBracketKeyword_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group_7__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group_7__1__Impl
	rule__ContinuationTransition__Group_7__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group_7__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getGroup_7_1()); }
(rule__ContinuationTransition__Group_7_1__0)?
{ after(grammarAccess.getContinuationTransitionAccess().getGroup_7_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group_7__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group_7__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group_7__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); }

	'}' 

{ after(grammarAccess.getContinuationTransitionAccess().getRightCurlyBracketKeyword_7_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ContinuationTransition__Group_7_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group_7_1__0__Impl
	rule__ContinuationTransition__Group_7_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group_7_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); }

	'action' 

{ after(grammarAccess.getContinuationTransitionAccess().getActionKeyword_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ContinuationTransition__Group_7_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ContinuationTransition__Group_7_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__Group_7_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getActionAssignment_7_1_1()); }
(rule__ContinuationTransition__ActionAssignment_7_1_1)
{ after(grammarAccess.getContinuationTransitionAccess().getActionAssignment_7_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__TriggeredTransition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__0__Impl
	rule__TriggeredTransition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); }

	'Transition' 

{ after(grammarAccess.getTriggeredTransitionAccess().getTransitionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__1__Impl
	rule__TriggeredTransition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getNameAssignment_1()); }
(rule__TriggeredTransition__NameAssignment_1)?
{ after(grammarAccess.getTriggeredTransitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__2__Impl
	rule__TriggeredTransition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__3__Impl
	rule__TriggeredTransition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getFromAssignment_3()); }
(rule__TriggeredTransition__FromAssignment_3)
{ after(grammarAccess.getTriggeredTransitionAccess().getFromAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__4__Impl
	rule__TriggeredTransition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }

	'->' 

{ after(grammarAccess.getTriggeredTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__5__Impl
	rule__TriggeredTransition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getToAssignment_5()); }
(rule__TriggeredTransition__ToAssignment_5)
{ after(grammarAccess.getTriggeredTransitionAccess().getToAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__6__Impl
	rule__TriggeredTransition__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getDocuAssignment_6()); }
(rule__TriggeredTransition__DocuAssignment_6)?
{ after(grammarAccess.getTriggeredTransitionAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__7__Impl
	rule__TriggeredTransition__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); }

	'{' 

{ after(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__8__Impl
	rule__TriggeredTransition__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); }

	'triggers' 

{ after(grammarAccess.getTriggeredTransitionAccess().getTriggersKeyword_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__9__Impl
	rule__TriggeredTransition__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); }

	'{' 

{ after(grammarAccess.getTriggeredTransitionAccess().getLeftCurlyBracketKeyword_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__10__Impl
	rule__TriggeredTransition__Group__11
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_10()); }
(rule__TriggeredTransition__TriggersAssignment_10)
{ after(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__11
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__11__Impl
	rule__TriggeredTransition__Group__12
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__11__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); }
(rule__TriggeredTransition__Group_11__0)*
{ after(grammarAccess.getTriggeredTransitionAccess().getGroup_11()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__12
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__12__Impl
	rule__TriggeredTransition__Group__13
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__12__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); }

	'}' 

{ after(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_12()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__13
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__13__Impl
	rule__TriggeredTransition__Group__14
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__13__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getGroup_13()); }
(rule__TriggeredTransition__Group_13__0)?
{ after(grammarAccess.getTriggeredTransitionAccess().getGroup_13()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group__14
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group__14__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group__14__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); }

	'}' 

{ after(grammarAccess.getTriggeredTransitionAccess().getRightCurlyBracketKeyword_14()); }
)

;
finally {
	restoreStackSize(stackSize);
}
































rule__TriggeredTransition__Group_11__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group_11__0__Impl
	rule__TriggeredTransition__Group_11__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group_11__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); }

	'or' 

{ after(grammarAccess.getTriggeredTransitionAccess().getOrKeyword_11_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group_11__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group_11__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group_11__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_11_1()); }
(rule__TriggeredTransition__TriggersAssignment_11_1)
{ after(grammarAccess.getTriggeredTransitionAccess().getTriggersAssignment_11_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__TriggeredTransition__Group_13__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group_13__0__Impl
	rule__TriggeredTransition__Group_13__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group_13__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); }

	'action' 

{ after(grammarAccess.getTriggeredTransitionAccess().getActionKeyword_13_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TriggeredTransition__Group_13__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TriggeredTransition__Group_13__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__Group_13__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getActionAssignment_13_1()); }
(rule__TriggeredTransition__ActionAssignment_13_1)
{ after(grammarAccess.getTriggeredTransitionAccess().getActionAssignment_13_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__GuardedTransition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__0__Impl
	rule__GuardedTransition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); }

	'Transition' 

{ after(grammarAccess.getGuardedTransitionAccess().getTransitionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__1__Impl
	rule__GuardedTransition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getNameAssignment_1()); }
(rule__GuardedTransition__NameAssignment_1)?
{ after(grammarAccess.getGuardedTransitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__2__Impl
	rule__GuardedTransition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__3__Impl
	rule__GuardedTransition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getFromAssignment_3()); }
(rule__GuardedTransition__FromAssignment_3)
{ after(grammarAccess.getGuardedTransitionAccess().getFromAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__4__Impl
	rule__GuardedTransition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }

	'->' 

{ after(grammarAccess.getGuardedTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__5__Impl
	rule__GuardedTransition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getToAssignment_5()); }
(rule__GuardedTransition__ToAssignment_5)
{ after(grammarAccess.getGuardedTransitionAccess().getToAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__6__Impl
	rule__GuardedTransition__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getDocuAssignment_6()); }
(rule__GuardedTransition__DocuAssignment_6)?
{ after(grammarAccess.getGuardedTransitionAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__7__Impl
	rule__GuardedTransition__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); }

	'{' 

{ after(grammarAccess.getGuardedTransitionAccess().getLeftCurlyBracketKeyword_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__8__Impl
	rule__GuardedTransition__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); }

	'guard' 

{ after(grammarAccess.getGuardedTransitionAccess().getGuardKeyword_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__9__Impl
	rule__GuardedTransition__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getGuardAssignment_9()); }
(rule__GuardedTransition__GuardAssignment_9)
{ after(grammarAccess.getGuardedTransitionAccess().getGuardAssignment_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__10__Impl
	rule__GuardedTransition__Group__11
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getGroup_10()); }
(rule__GuardedTransition__Group_10__0)?
{ after(grammarAccess.getGuardedTransitionAccess().getGroup_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group__11
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group__11__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group__11__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); }

	'}' 

{ after(grammarAccess.getGuardedTransitionAccess().getRightCurlyBracketKeyword_11()); }
)

;
finally {
	restoreStackSize(stackSize);
}


























rule__GuardedTransition__Group_10__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group_10__0__Impl
	rule__GuardedTransition__Group_10__1
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group_10__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); }

	'action' 

{ after(grammarAccess.getGuardedTransitionAccess().getActionKeyword_10_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__GuardedTransition__Group_10__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__GuardedTransition__Group_10__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__Group_10__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getActionAssignment_10_1()); }
(rule__GuardedTransition__ActionAssignment_10_1)
{ after(grammarAccess.getGuardedTransitionAccess().getActionAssignment_10_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__CPBranchTransition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__0__Impl
	rule__CPBranchTransition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); }

	'Transition' 

{ after(grammarAccess.getCPBranchTransitionAccess().getTransitionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__1__Impl
	rule__CPBranchTransition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getNameAssignment_1()); }
(rule__CPBranchTransition__NameAssignment_1)?
{ after(grammarAccess.getCPBranchTransitionAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__2__Impl
	rule__CPBranchTransition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	':' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__3__Impl
	rule__CPBranchTransition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getFromAssignment_3()); }
(rule__CPBranchTransition__FromAssignment_3)
{ after(grammarAccess.getCPBranchTransitionAccess().getFromAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__4__Impl
	rule__CPBranchTransition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }

	'->' 

{ after(grammarAccess.getCPBranchTransitionAccess().getHyphenMinusGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__5__Impl
	rule__CPBranchTransition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getToAssignment_5()); }
(rule__CPBranchTransition__ToAssignment_5)
{ after(grammarAccess.getCPBranchTransitionAccess().getToAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__6__Impl
	rule__CPBranchTransition__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getDocuAssignment_6()); }
(rule__CPBranchTransition__DocuAssignment_6)?
{ after(grammarAccess.getCPBranchTransitionAccess().getDocuAssignment_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__7__Impl
	rule__CPBranchTransition__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); }

	'{' 

{ after(grammarAccess.getCPBranchTransitionAccess().getLeftCurlyBracketKeyword_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__8__Impl
	rule__CPBranchTransition__Group__9
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); }

	'cond' 

{ after(grammarAccess.getCPBranchTransitionAccess().getCondKeyword_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__9
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__9__Impl
	rule__CPBranchTransition__Group__10
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__9__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getConditionAssignment_9()); }
(rule__CPBranchTransition__ConditionAssignment_9)
{ after(grammarAccess.getCPBranchTransitionAccess().getConditionAssignment_9()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__10
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__10__Impl
	rule__CPBranchTransition__Group__11
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__10__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getGroup_10()); }
(rule__CPBranchTransition__Group_10__0)?
{ after(grammarAccess.getCPBranchTransitionAccess().getGroup_10()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group__11
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group__11__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group__11__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); }

	'}' 

{ after(grammarAccess.getCPBranchTransitionAccess().getRightCurlyBracketKeyword_11()); }
)

;
finally {
	restoreStackSize(stackSize);
}


























rule__CPBranchTransition__Group_10__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group_10__0__Impl
	rule__CPBranchTransition__Group_10__1
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group_10__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); }

	'action' 

{ after(grammarAccess.getCPBranchTransitionAccess().getActionKeyword_10_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__CPBranchTransition__Group_10__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__CPBranchTransition__Group_10__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__Group_10__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getActionAssignment_10_1()); }
(rule__CPBranchTransition__ActionAssignment_10_1)
{ after(grammarAccess.getCPBranchTransitionAccess().getActionAssignment_10_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RefinedTransition__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__0__Impl
	rule__RefinedTransition__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); }

	'RefinedTransition' 

{ after(grammarAccess.getRefinedTransitionAccess().getRefinedTransitionKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedTransition__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__1__Impl
	rule__RefinedTransition__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getTargetAssignment_1()); }
(rule__RefinedTransition__TargetAssignment_1)
{ after(grammarAccess.getRefinedTransitionAccess().getTargetAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedTransition__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__2__Impl
	rule__RefinedTransition__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getDocuAssignment_2()); }
(rule__RefinedTransition__DocuAssignment_2)?
{ after(grammarAccess.getRefinedTransitionAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedTransition__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__3__Impl
	rule__RefinedTransition__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getRefinedTransitionAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedTransition__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__4__Impl
	rule__RefinedTransition__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); }

	'action' 

{ after(grammarAccess.getRefinedTransitionAccess().getActionKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedTransition__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__5__Impl
	rule__RefinedTransition__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getActionAssignment_5()); }
(rule__RefinedTransition__ActionAssignment_5)
{ after(grammarAccess.getRefinedTransitionAccess().getActionAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RefinedTransition__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RefinedTransition__Group__6__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); }

	'}' 

{ after(grammarAccess.getRefinedTransitionAccess().getRightCurlyBracketKeyword_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__TrPointTerminal__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TrPointTerminal__Group__0__Impl
	rule__TrPointTerminal__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__TrPointTerminal__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); }

	'my' 

{ after(grammarAccess.getTrPointTerminalAccess().getMyKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__TrPointTerminal__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__TrPointTerminal__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__TrPointTerminal__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTrPointTerminalAccess().getTrPointAssignment_1()); }
(rule__TrPointTerminal__TrPointAssignment_1)
{ after(grammarAccess.getTrPointTerminalAccess().getTrPointAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SubStateTrPointTerminal__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubStateTrPointTerminal__Group__0__Impl
	rule__SubStateTrPointTerminal__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SubStateTrPointTerminal__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointAssignment_0()); }
(rule__SubStateTrPointTerminal__TrPointAssignment_0)
{ after(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubStateTrPointTerminal__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubStateTrPointTerminal__Group__1__Impl
	rule__SubStateTrPointTerminal__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SubStateTrPointTerminal__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); }

	'of' 

{ after(grammarAccess.getSubStateTrPointTerminalAccess().getOfKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SubStateTrPointTerminal__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SubStateTrPointTerminal__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SubStateTrPointTerminal__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getStateAssignment_2()); }
(rule__SubStateTrPointTerminal__StateAssignment_2)
{ after(grammarAccess.getSubStateTrPointTerminalAccess().getStateAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__ChoicepointTerminal__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ChoicepointTerminal__Group__0__Impl
	rule__ChoicepointTerminal__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicepointTerminal__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); }

	'cp' 

{ after(grammarAccess.getChoicepointTerminalAccess().getCpKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ChoicepointTerminal__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ChoicepointTerminal__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicepointTerminal__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicepointTerminalAccess().getCpAssignment_1()); }
(rule__ChoicepointTerminal__CpAssignment_1)
{ after(grammarAccess.getChoicepointTerminalAccess().getCpAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Trigger__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group__0__Impl
	rule__Trigger__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); }

	'<' 

{ after(grammarAccess.getTriggerAccess().getLessThanSignKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Trigger__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group__1__Impl
	rule__Trigger__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_1()); }
(rule__Trigger__MsgFromIfPairsAssignment_1)
{ after(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Trigger__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group__2__Impl
	rule__Trigger__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getGroup_2()); }
(rule__Trigger__Group_2__0)*
{ after(grammarAccess.getTriggerAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Trigger__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group__3__Impl
	rule__Trigger__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getGuardAssignment_3()); }
(rule__Trigger__GuardAssignment_3)?
{ after(grammarAccess.getTriggerAccess().getGuardAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Trigger__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); }

	'>' 

{ after(grammarAccess.getTriggerAccess().getGreaterThanSignKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__Trigger__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group_2__0__Impl
	rule__Trigger__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); }

	'|' 

{ after(grammarAccess.getTriggerAccess().getVerticalLineKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Trigger__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Trigger__Group_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_2_1()); }
(rule__Trigger__MsgFromIfPairsAssignment_2_1)
{ after(grammarAccess.getTriggerAccess().getMsgFromIfPairsAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__MessageFromIf__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MessageFromIf__Group__0__Impl
	rule__MessageFromIf__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__MessageFromIf__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageFromIfAccess().getMessageAssignment_0()); }
(rule__MessageFromIf__MessageAssignment_0)
{ after(grammarAccess.getMessageFromIfAccess().getMessageAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MessageFromIf__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MessageFromIf__Group__1__Impl
	rule__MessageFromIf__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__MessageFromIf__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); }

	':' 

{ after(grammarAccess.getMessageFromIfAccess().getColonKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__MessageFromIf__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__MessageFromIf__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__MessageFromIf__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageFromIfAccess().getFromAssignment_2()); }
(rule__MessageFromIf__FromAssignment_2)
{ after(grammarAccess.getMessageFromIfAccess().getFromAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__Guard__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Guard__Group__0__Impl
	rule__Guard__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Guard__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardAccess().getGuardKeyword_0()); }

	'guard' 

{ after(grammarAccess.getGuardAccess().getGuardKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Guard__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Guard__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Guard__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardAccess().getGuardAssignment_1()); }
(rule__Guard__GuardAssignment_1)
{ after(grammarAccess.getGuardAccess().getGuardAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ProtocolSemantics__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolSemantics__Group__0__Impl
	rule__ProtocolSemantics__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolSemantics__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolSemanticsAccess().getProtocolSemanticsAction_0()); }
(

)
{ after(grammarAccess.getProtocolSemanticsAccess().getProtocolSemanticsAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolSemantics__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolSemantics__Group__1__Impl
	rule__ProtocolSemantics__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolSemantics__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolSemanticsAccess().getSemanticsKeyword_1()); }

	'semantics' 

{ after(grammarAccess.getProtocolSemanticsAccess().getSemanticsKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolSemantics__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolSemantics__Group__2__Impl
	rule__ProtocolSemantics__Group__3
;
finally {
	restoreStackSize(stackSize);
}

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

	'{' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolSemantics__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolSemantics__Group__3__Impl
	rule__ProtocolSemantics__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolSemantics__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolSemanticsAccess().getRulesAssignment_3()); }
(rule__ProtocolSemantics__RulesAssignment_3)*
{ after(grammarAccess.getProtocolSemanticsAccess().getRulesAssignment_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ProtocolSemantics__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ProtocolSemantics__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolSemantics__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolSemanticsAccess().getRightCurlyBracketKeyword_4()); }

	'}' 

{ after(grammarAccess.getProtocolSemanticsAccess().getRightCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__InSemanticsRule__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group__0__Impl
	rule__InSemanticsRule__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); }

	'in' 

{ after(grammarAccess.getInSemanticsRuleAccess().getInKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group__1__Impl
	rule__InSemanticsRule__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); }

	':' 

{ after(grammarAccess.getInSemanticsRuleAccess().getColonKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group__2__Impl
	rule__InSemanticsRule__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getMsgAssignment_2()); }
(rule__InSemanticsRule__MsgAssignment_2)
{ after(grammarAccess.getInSemanticsRuleAccess().getMsgAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getGroup_3()); }
(rule__InSemanticsRule__Group_3__0)?
{ after(grammarAccess.getInSemanticsRuleAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__InSemanticsRule__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3__0__Impl
	rule__InSemanticsRule__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); }

	'->' 

{ after(grammarAccess.getInSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getAlternatives_3_1()); }
(rule__InSemanticsRule__Alternatives_3_1)
{ after(grammarAccess.getInSemanticsRuleAccess().getAlternatives_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__InSemanticsRule__Group_3_1_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3_1_1__0__Impl
	rule__InSemanticsRule__Group_3_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3_1_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); }

	'(' 

{ after(grammarAccess.getInSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group_3_1_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3_1_1__1__Impl
	rule__InSemanticsRule__Group_3_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3_1_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); }
(rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1)
{ after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group_3_1_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3_1_1__2__Impl
	rule__InSemanticsRule__Group_3_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3_1_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
(
{ before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); }
(rule__InSemanticsRule__Group_3_1_1_2__0)
{ after(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); }
)
(
{ before(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); }
(rule__InSemanticsRule__Group_3_1_1_2__0)*
{ after(grammarAccess.getInSemanticsRuleAccess().getGroup_3_1_1_2()); }
)
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group_3_1_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3_1_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); }

	')' 

{ after(grammarAccess.getInSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__InSemanticsRule__Group_3_1_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3_1_1_2__0__Impl
	rule__InSemanticsRule__Group_3_1_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3_1_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); }

	',' 

{ after(grammarAccess.getInSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__InSemanticsRule__Group_3_1_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__InSemanticsRule__Group_3_1_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__Group_3_1_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); }
(rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1)
{ after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__OutSemanticsRule__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group__0__Impl
	rule__OutSemanticsRule__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); }

	'out' 

{ after(grammarAccess.getOutSemanticsRuleAccess().getOutKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group__1__Impl
	rule__OutSemanticsRule__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); }

	':' 

{ after(grammarAccess.getOutSemanticsRuleAccess().getColonKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group__2__Impl
	rule__OutSemanticsRule__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getMsgAssignment_2()); }
(rule__OutSemanticsRule__MsgAssignment_2)
{ after(grammarAccess.getOutSemanticsRuleAccess().getMsgAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3()); }
(rule__OutSemanticsRule__Group_3__0)?
{ after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__OutSemanticsRule__Group_3__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3__0__Impl
	rule__OutSemanticsRule__Group_3__1
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); }

	'->' 

{ after(grammarAccess.getOutSemanticsRuleAccess().getHyphenMinusGreaterThanSignKeyword_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group_3__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getAlternatives_3_1()); }
(rule__OutSemanticsRule__Alternatives_3_1)
{ after(grammarAccess.getOutSemanticsRuleAccess().getAlternatives_3_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__OutSemanticsRule__Group_3_1_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3_1_1__0__Impl
	rule__OutSemanticsRule__Group_3_1_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3_1_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); }

	'(' 

{ after(grammarAccess.getOutSemanticsRuleAccess().getLeftParenthesisKeyword_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group_3_1_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3_1_1__1__Impl
	rule__OutSemanticsRule__Group_3_1_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3_1_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); }
(rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1)
{ after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group_3_1_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3_1_1__2__Impl
	rule__OutSemanticsRule__Group_3_1_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3_1_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); }
(rule__OutSemanticsRule__Group_3_1_1_2__0)
{ after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); }
)
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); }
(rule__OutSemanticsRule__Group_3_1_1_2__0)*
{ after(grammarAccess.getOutSemanticsRuleAccess().getGroup_3_1_1_2()); }
)
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group_3_1_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3_1_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3_1_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); }

	')' 

{ after(grammarAccess.getOutSemanticsRuleAccess().getRightParenthesisKeyword_3_1_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__OutSemanticsRule__Group_3_1_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3_1_1_2__0__Impl
	rule__OutSemanticsRule__Group_3_1_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3_1_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); }

	',' 

{ after(grammarAccess.getOutSemanticsRuleAccess().getCommaKeyword_3_1_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__OutSemanticsRule__Group_3_1_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__Group_3_1_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); }
(rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1)
{ after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsAssignment_3_1_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Annotation__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group__0__Impl
	rule__Annotation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getCommercialAtKeyword_0()); }

	'@' 

{ after(grammarAccess.getAnnotationAccess().getCommercialAtKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Annotation__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group__1__Impl
	rule__Annotation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getTypeAssignment_1()); }
(rule__Annotation__TypeAssignment_1)
{ after(grammarAccess.getAnnotationAccess().getTypeAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Annotation__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getGroup_2()); }
(rule__Annotation__Group_2__0)?
{ after(grammarAccess.getAnnotationAccess().getGroup_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__Annotation__Group_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group_2__0__Impl
	rule__Annotation__Group_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_2_0()); }

	'(' 

{ after(grammarAccess.getAnnotationAccess().getLeftParenthesisKeyword_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Annotation__Group_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group_2__1__Impl
	rule__Annotation__Group_2__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getAttributesAssignment_2_1()); }
(rule__Annotation__AttributesAssignment_2_1)
{ after(grammarAccess.getAnnotationAccess().getAttributesAssignment_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Annotation__Group_2__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group_2__2__Impl
	rule__Annotation__Group_2__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group_2__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getGroup_2_2()); }
(rule__Annotation__Group_2_2__0)*
{ after(grammarAccess.getAnnotationAccess().getGroup_2_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Annotation__Group_2__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group_2__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group_2__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_2_3()); }

	')' 

{ after(grammarAccess.getAnnotationAccess().getRightParenthesisKeyword_2_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__Annotation__Group_2_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group_2_2__0__Impl
	rule__Annotation__Group_2_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group_2_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getCommaKeyword_2_2_0()); }

	',' 

{ after(grammarAccess.getAnnotationAccess().getCommaKeyword_2_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Annotation__Group_2_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Annotation__Group_2_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__Group_2_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getAttributesAssignment_2_2_1()); }
(rule__Annotation__AttributesAssignment_2_2_1)
{ after(grammarAccess.getAnnotationAccess().getAttributesAssignment_2_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__KeyValue__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__KeyValue__Group__0__Impl
	rule__KeyValue__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__KeyValue__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getKeyValueAccess().getKeyAssignment_0()); }
(rule__KeyValue__KeyAssignment_0)
{ after(grammarAccess.getKeyValueAccess().getKeyAssignment_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__KeyValue__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__KeyValue__Group__1__Impl
	rule__KeyValue__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__KeyValue__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); }

	'=' 

{ after(grammarAccess.getKeyValueAccess().getEqualsSignKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__KeyValue__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__KeyValue__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__KeyValue__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getKeyValueAccess().getValueAssignment_2()); }
(rule__KeyValue__ValueAssignment_2)
{ after(grammarAccess.getKeyValueAccess().getValueAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__AnnotationType__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__0__Impl
	rule__AnnotationType__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getAnnotationTypeKeyword_0()); }

	'AnnotationType' 

{ after(grammarAccess.getAnnotationTypeAccess().getAnnotationTypeKeyword_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__1__Impl
	rule__AnnotationType__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getNameAssignment_1()); }
(rule__AnnotationType__NameAssignment_1)
{ after(grammarAccess.getAnnotationTypeAccess().getNameAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__2__Impl
	rule__AnnotationType__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getDocuAssignment_2()); }
(rule__AnnotationType__DocuAssignment_2)?
{ after(grammarAccess.getAnnotationTypeAccess().getDocuAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__3__Impl
	rule__AnnotationType__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_3()); }

	'{' 

{ after(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__4__Impl
	rule__AnnotationType__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetKeyword_4()); }

	'target' 

{ after(grammarAccess.getAnnotationTypeAccess().getTargetKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__5__Impl
	rule__AnnotationType__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getEqualsSignKeyword_5()); }

	'=' 

{ after(grammarAccess.getAnnotationTypeAccess().getEqualsSignKeyword_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__6__Impl
	rule__AnnotationType__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getAlternatives_6()); }
(rule__AnnotationType__Alternatives_6)
{ after(grammarAccess.getAnnotationTypeAccess().getAlternatives_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__7__Impl
	rule__AnnotationType__Group__8
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getAttributesAssignment_7()); }
(rule__AnnotationType__AttributesAssignment_7)*
{ after(grammarAccess.getAnnotationTypeAccess().getAttributesAssignment_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group__8
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group__8__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group__8__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_8()); }

	'}' 

{ after(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_8()); }
)

;
finally {
	restoreStackSize(stackSize);
}




















rule__AnnotationType__Group_6_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group_6_1__0__Impl
	rule__AnnotationType__Group_6_1__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group_6_1__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_6_1_0()); }

	'{' 

{ after(grammarAccess.getAnnotationTypeAccess().getLeftCurlyBracketKeyword_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group_6_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group_6_1__1__Impl
	rule__AnnotationType__Group_6_1__2
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group_6_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_1_1()); }
(rule__AnnotationType__TargetsAssignment_6_1_1)
{ after(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group_6_1__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group_6_1__2__Impl
	rule__AnnotationType__Group_6_1__3
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group_6_1__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getGroup_6_1_2()); }
(rule__AnnotationType__Group_6_1_2__0)*
{ after(grammarAccess.getAnnotationTypeAccess().getGroup_6_1_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group_6_1__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group_6_1__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group_6_1__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_6_1_3()); }

	'}' 

{ after(grammarAccess.getAnnotationTypeAccess().getRightCurlyBracketKeyword_6_1_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__AnnotationType__Group_6_1_2__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group_6_1_2__0__Impl
	rule__AnnotationType__Group_6_1_2__1
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group_6_1_2__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getCommaKeyword_6_1_2_0()); }

	',' 

{ after(grammarAccess.getAnnotationTypeAccess().getCommaKeyword_6_1_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__AnnotationType__Group_6_1_2__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__AnnotationType__Group_6_1_2__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__Group_6_1_2__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_1_2_1()); }
(rule__AnnotationType__TargetsAssignment_6_1_2_1)
{ after(grammarAccess.getAnnotationTypeAccess().getTargetsAssignment_6_1_2_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SimpleAnnotationAttribute__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleAnnotationAttribute__Group__0__Impl
	rule__SimpleAnnotationAttribute__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getAlternatives_0()); }
(rule__SimpleAnnotationAttribute__Alternatives_0)
{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleAnnotationAttribute__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleAnnotationAttribute__Group__1__Impl
	rule__SimpleAnnotationAttribute__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); }

	'attribute' 

{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getAttributeKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleAnnotationAttribute__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleAnnotationAttribute__Group__2__Impl
	rule__SimpleAnnotationAttribute__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameAssignment_2()); }
(rule__SimpleAnnotationAttribute__NameAssignment_2)
{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleAnnotationAttribute__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleAnnotationAttribute__Group__3__Impl
	rule__SimpleAnnotationAttribute__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); }

	':' 

{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getColonKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SimpleAnnotationAttribute__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SimpleAnnotationAttribute__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeAssignment_4()); }
(rule__SimpleAnnotationAttribute__TypeAssignment_4)
{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeAssignment_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__EnumAnnotationAttribute__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__0__Impl
	rule__EnumAnnotationAttribute__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getAlternatives_0()); }
(rule__EnumAnnotationAttribute__Alternatives_0)
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__1__Impl
	rule__EnumAnnotationAttribute__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); }

	'attribute' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getAttributeKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__2__Impl
	rule__EnumAnnotationAttribute__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getNameAssignment_2()); }
(rule__EnumAnnotationAttribute__NameAssignment_2)
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getNameAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__3__Impl
	rule__EnumAnnotationAttribute__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); }

	':' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getColonKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__4__Impl
	rule__EnumAnnotationAttribute__Group__5
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); }

	'{' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getLeftCurlyBracketKeyword_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__5
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__5__Impl
	rule__EnumAnnotationAttribute__Group__6
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__5__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_5()); }
(rule__EnumAnnotationAttribute__ValuesAssignment_5)
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_5()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__6
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__6__Impl
	rule__EnumAnnotationAttribute__Group__7
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__6__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); }
(rule__EnumAnnotationAttribute__Group_6__0)*
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getGroup_6()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group__7
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group__7__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group__7__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); }

	'}' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getRightCurlyBracketKeyword_7()); }
)

;
finally {
	restoreStackSize(stackSize);
}


















rule__EnumAnnotationAttribute__Group_6__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group_6__0__Impl
	rule__EnumAnnotationAttribute__Group_6__1
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group_6__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); }

	',' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getCommaKeyword_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__EnumAnnotationAttribute__Group_6__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__EnumAnnotationAttribute__Group_6__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__Group_6__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_6_1()); }
(rule__EnumAnnotationAttribute__ValuesAssignment_6_1)
{ after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesAssignment_6_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Import__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Import__Group__0__Impl
	rule__Import__Group__1
;
finally {
	restoreStackSize(stackSize);
}

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

	'import' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__Import__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Import__Group__1__Impl
	rule__Import__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Import__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getAlternatives_1()); }
(rule__Import__Alternatives_1)
{ after(grammarAccess.getImportAccess().getAlternatives_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Import__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Import__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Import__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getImportURIAssignment_2()); }
(rule__Import__ImportURIAssignment_2)
{ after(grammarAccess.getImportAccess().getImportURIAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__Import__Group_1_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Import__Group_1_0__0__Impl
	rule__Import__Group_1_0__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Import__Group_1_0__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getImportedNamespaceAssignment_1_0_0()); }
(rule__Import__ImportedNamespaceAssignment_1_0_0)
{ after(grammarAccess.getImportAccess().getImportedNamespaceAssignment_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Import__Group_1_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Import__Group_1_0__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Import__Group_1_0__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getFromKeyword_1_0_1()); }

	'from' 

{ after(grammarAccess.getImportAccess().getFromKeyword_1_0_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__ImportedFQN__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImportedFQN__Group__0__Impl
	rule__ImportedFQN__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__ImportedFQN__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); }
	ruleFQN
{ after(grammarAccess.getImportedFQNAccess().getFQNParserRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__ImportedFQN__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ImportedFQN__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__ImportedFQN__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); }
(
	'.*' 
)?
{ after(grammarAccess.getImportedFQNAccess().getFullStopAsteriskKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Documentation__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Documentation__Group__0__Impl
	rule__Documentation__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Documentation__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); }
(

)
{ after(grammarAccess.getDocumentationAccess().getDocumentationAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Documentation__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Documentation__Group__1__Impl
	rule__Documentation__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Documentation__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); }

	'[' 

{ after(grammarAccess.getDocumentationAccess().getLeftSquareBracketKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Documentation__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Documentation__Group__2__Impl
	rule__Documentation__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Documentation__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); }
(rule__Documentation__LinesAssignment_2)*
{ after(grammarAccess.getDocumentationAccess().getLinesAssignment_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Documentation__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Documentation__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Documentation__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); }

	']' 

{ after(grammarAccess.getDocumentationAccess().getRightSquareBracketKeyword_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}
















rule__BooleanLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BooleanLiteral__Group__0__Impl
	rule__BooleanLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); }
(

)
{ after(grammarAccess.getBooleanLiteralAccess().getBooleanLiteralAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__BooleanLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__BooleanLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__BooleanLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); }
(rule__BooleanLiteral__Alternatives_1)
{ after(grammarAccess.getBooleanLiteralAccess().getAlternatives_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__RealLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealLiteral__Group__0__Impl
	rule__RealLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); }
(

)
{ after(grammarAccess.getRealLiteralAccess().getRealLiteralAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__RealLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__RealLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getValueAssignment_1()); }
(rule__RealLiteral__ValueAssignment_1)
{ after(grammarAccess.getRealLiteralAccess().getValueAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__IntLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntLiteral__Group__0__Impl
	rule__IntLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__IntLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); }
(

)
{ after(grammarAccess.getIntLiteralAccess().getIntLiteralAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__IntLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__IntLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__IntLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntLiteralAccess().getValueAssignment_1()); }
(rule__IntLiteral__ValueAssignment_1)
{ after(grammarAccess.getIntLiteralAccess().getValueAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__StringLiteral__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StringLiteral__Group__0__Impl
	rule__StringLiteral__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__StringLiteral__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); }
(

)
{ after(grammarAccess.getStringLiteralAccess().getStringLiteralAction_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StringLiteral__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__StringLiteral__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__StringLiteral__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStringLiteralAccess().getValueAssignment_1()); }
(rule__StringLiteral__ValueAssignment_1)
{ after(grammarAccess.getStringLiteralAccess().getValueAssignment_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__SignedInteger__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SignedInteger__Group__0__Impl
	rule__SignedInteger__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__SignedInteger__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSignedIntegerAccess().getAlternatives_0()); }
(rule__SignedInteger__Alternatives_0)?
{ after(grammarAccess.getSignedIntegerAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__SignedInteger__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__SignedInteger__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__SignedInteger__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSignedIntegerAccess().getINTTerminalRuleCall_1()); }
	RULE_INT
{ after(grammarAccess.getSignedIntegerAccess().getINTTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__Decimal__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Decimal__Group__0__Impl
	rule__Decimal__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__Decimal__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalAccess().getAlternatives_0()); }
(rule__Decimal__Alternatives_0)?
{ after(grammarAccess.getDecimalAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Decimal__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Decimal__Group__1__Impl
	rule__Decimal__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__Decimal__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); }
	RULE_INT
{ after(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Decimal__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Decimal__Group__2__Impl
	rule__Decimal__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__Decimal__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); }

	'.' 

{ after(grammarAccess.getDecimalAccess().getFullStopKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__Decimal__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__Decimal__Group__3__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__Decimal__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); }
	RULE_INT
{ after(grammarAccess.getDecimalAccess().getINTTerminalRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}










rule__DotDecimal__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DotDecimal__Group__0__Impl
	rule__DotDecimal__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DotDecimal__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDotDecimalAccess().getAlternatives_0()); }
(rule__DotDecimal__Alternatives_0)?
{ after(grammarAccess.getDotDecimalAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DotDecimal__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DotDecimal__Group__1__Impl
	rule__DotDecimal__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DotDecimal__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDotDecimalAccess().getFullStopKeyword_1()); }

	'.' 

{ after(grammarAccess.getDotDecimalAccess().getFullStopKeyword_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DotDecimal__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DotDecimal__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DotDecimal__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDotDecimalAccess().getINTTerminalRuleCall_2()); }
	RULE_INT
{ after(grammarAccess.getDotDecimalAccess().getINTTerminalRuleCall_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__DecimalDot__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalDot__Group__0__Impl
	rule__DecimalDot__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalDot__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalDotAccess().getAlternatives_0()); }
(rule__DecimalDot__Alternatives_0)?
{ after(grammarAccess.getDecimalDotAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalDot__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalDot__Group__1__Impl
	rule__DecimalDot__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalDot__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalDotAccess().getINTTerminalRuleCall_1()); }
	RULE_INT
{ after(grammarAccess.getDecimalDotAccess().getINTTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalDot__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalDot__Group__2__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalDot__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalDotAccess().getFullStopKeyword_2()); }

	'.' 

{ after(grammarAccess.getDecimalDotAccess().getFullStopKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}








rule__DecimalExp__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalExp__Group__0__Impl
	rule__DecimalExp__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalExp__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalExpAccess().getAlternatives_0()); }
(rule__DecimalExp__Alternatives_0)?
{ after(grammarAccess.getDecimalExpAccess().getAlternatives_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalExp__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalExp__Group__1__Impl
	rule__DecimalExp__Group__2
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalExp__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); }
	RULE_INT
{ after(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalExp__Group__2
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalExp__Group__2__Impl
	rule__DecimalExp__Group__3
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalExp__Group__2__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); }

	'.' 

{ after(grammarAccess.getDecimalExpAccess().getFullStopKeyword_2()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalExp__Group__3
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalExp__Group__3__Impl
	rule__DecimalExp__Group__4
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalExp__Group__3__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); }
	RULE_INT
{ after(grammarAccess.getDecimalExpAccess().getINTTerminalRuleCall_3()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__DecimalExp__Group__4
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__DecimalExp__Group__4__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__DecimalExp__Group__4__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDecimalExpAccess().getEXPTerminalRuleCall_4()); }
	RULE_EXP
{ after(grammarAccess.getDecimalExpAccess().getEXPTerminalRuleCall_4()); }
)

;
finally {
	restoreStackSize(stackSize);
}












rule__FQN__Group__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FQN__Group__0__Impl
	rule__FQN__Group__1
;
finally {
	restoreStackSize(stackSize);
}

rule__FQN__Group__0__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); }
	RULE_ID
{ after(grammarAccess.getFQNAccess().getIDTerminalRuleCall_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__FQN__Group__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FQN__Group__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FQN__Group__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFQNAccess().getGroup_1()); }
(rule__FQN__Group_1__0)*
{ after(grammarAccess.getFQNAccess().getGroup_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}






rule__FQN__Group_1__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FQN__Group_1__0__Impl
	rule__FQN__Group_1__1
;
finally {
	restoreStackSize(stackSize);
}

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

	'.' 

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

;
finally {
	restoreStackSize(stackSize);
}


rule__FQN__Group_1__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__FQN__Group_1__1__Impl
;
finally {
	restoreStackSize(stackSize);
}

rule__FQN__Group_1__1__Impl
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); }
	RULE_ID
{ after(grammarAccess.getFQNAccess().getIDTerminalRuleCall_1_1()); }
)

;
finally {
	restoreStackSize(stackSize);
}







rule__ActorClass__UnorderedGroup_0
    @init {
    	int stackSize = keepStackSize();
		getUnorderedGroupHelper().enter(grammarAccess.getActorClassAccess().getUnorderedGroup_0());
    }
:
	rule__ActorClass__UnorderedGroup_0__0
	?
	
;
finally {
	getUnorderedGroupHelper().leave(grammarAccess.getActorClassAccess().getUnorderedGroup_0());
	restoreStackSize(stackSize);
}


rule__ActorClass__UnorderedGroup_0__Impl
	@init {
		int stackSize = keepStackSize();
		boolean selected = false;
    }
:
		(

			( 
				{getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0)}?=>(
					{ 
	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 0);
	 				}
	 				{
	 				  selected = true;
	 				}
					(
					
						{ before(grammarAccess.getActorClassAccess().getAbstractAssignment_0_0()); }
						(rule__ActorClass__AbstractAssignment_0_0)
						{ after(grammarAccess.getActorClassAccess().getAbstractAssignment_0_0()); }
					)
 				)
			)  |

			( 
				{getUnorderedGroupHelper().canSelect(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1)}?=>(
					{ 
	 				  getUnorderedGroupHelper().select(grammarAccess.getActorClassAccess().getUnorderedGroup_0(), 1);
	 				}
	 				{
	 				  selected = true;
	 				}
					(
					
						{ before(grammarAccess.getActorClassAccess().getCommTypeAssignment_0_1()); }
						(rule__ActorClass__CommTypeAssignment_0_1)
						{ after(grammarAccess.getActorClassAccess().getCommTypeAssignment_0_1()); }
					)
 				)
			)  

		)
;
finally {
	if (selected)
		getUnorderedGroupHelper().returnFromSelection(grammarAccess.getActorClassAccess().getUnorderedGroup_0());
	restoreStackSize(stackSize);
}


rule__ActorClass__UnorderedGroup_0__0
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__UnorderedGroup_0__Impl
	rule__ActorClass__UnorderedGroup_0__1?
;
finally {
	restoreStackSize(stackSize);
}


rule__ActorClass__UnorderedGroup_0__1
    @init {
		int stackSize = keepStackSize();
    }
:
	rule__ActorClass__UnorderedGroup_0__Impl
;
finally {
	restoreStackSize(stackSize);
}






rule__RoomModel__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getNameFQNParserRuleCall_1_0()); }
	ruleFQN{ after(grammarAccess.getRoomModelAccess().getNameFQNParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getRoomModelAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__ImportsAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getImportsImportParserRuleCall_4_0()); }
	ruleImport{ after(grammarAccess.getRoomModelAccess().getImportsImportParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__PrimitiveTypesAssignment_5_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getPrimitiveTypesPrimitiveTypeParserRuleCall_5_0_0()); }
	rulePrimitiveType{ after(grammarAccess.getRoomModelAccess().getPrimitiveTypesPrimitiveTypeParserRuleCall_5_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__EnumerationTypesAssignment_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getEnumerationTypesEnumerationTypeParserRuleCall_5_1_0()); }
	ruleEnumerationType{ after(grammarAccess.getRoomModelAccess().getEnumerationTypesEnumerationTypeParserRuleCall_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__ExternalTypesAssignment_5_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getExternalTypesExternalTypeParserRuleCall_5_2_0()); }
	ruleExternalType{ after(grammarAccess.getRoomModelAccess().getExternalTypesExternalTypeParserRuleCall_5_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__DataClassesAssignment_5_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getDataClassesDataClassParserRuleCall_5_3_0()); }
	ruleDataClass{ after(grammarAccess.getRoomModelAccess().getDataClassesDataClassParserRuleCall_5_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__ProtocolClassesAssignment_5_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getProtocolClassesGeneralProtocolClassParserRuleCall_5_4_0()); }
	ruleGeneralProtocolClass{ after(grammarAccess.getRoomModelAccess().getProtocolClassesGeneralProtocolClassParserRuleCall_5_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__ActorClassesAssignment_5_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getActorClassesActorClassParserRuleCall_5_5_0()); }
	ruleActorClass{ after(grammarAccess.getRoomModelAccess().getActorClassesActorClassParserRuleCall_5_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__SubSystemClassesAssignment_5_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getSubSystemClassesSubSystemClassParserRuleCall_5_6_0()); }
	ruleSubSystemClass{ after(grammarAccess.getRoomModelAccess().getSubSystemClassesSubSystemClassParserRuleCall_5_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__SystemsAssignment_5_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getSystemsLogicalSystemParserRuleCall_5_7_0()); }
	ruleLogicalSystem{ after(grammarAccess.getRoomModelAccess().getSystemsLogicalSystemParserRuleCall_5_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RoomModel__AnnotationTypesAssignment_5_8
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRoomModelAccess().getAnnotationTypesAnnotationTypeParserRuleCall_5_8_0()); }
	ruleAnnotationType{ after(grammarAccess.getRoomModelAccess().getAnnotationTypesAnnotationTypeParserRuleCall_5_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__VarDecl__NameAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVarDeclAccess().getNameIDTerminalRuleCall_0_0()); }
	RULE_ID{ after(grammarAccess.getVarDeclAccess().getNameIDTerminalRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__VarDecl__RefTypeAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getVarDeclAccess().getRefTypeRefableTypeParserRuleCall_2_0()); }
	ruleRefableType{ after(grammarAccess.getVarDeclAccess().getRefTypeRefableTypeParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefableType__TypeAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefableTypeAccess().getTypeDataTypeCrossReference_0_0()); }
(
{ before(grammarAccess.getRefableTypeAccess().getTypeDataTypeFQNParserRuleCall_0_0_1()); }
	ruleFQN{ after(grammarAccess.getRefableTypeAccess().getTypeDataTypeFQNParserRuleCall_0_0_1()); }
)
{ after(grammarAccess.getRefableTypeAccess().getTypeDataTypeCrossReference_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefableType__RefAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); }
(
{ before(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); }

	'ref' 

{ after(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); }
)

{ after(grammarAccess.getRefableTypeAccess().getRefRefKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getPrimitiveTypeAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__TypeAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getTypeLiteralTypeEnumRuleCall_3_0()); }
	ruleLiteralType{ after(grammarAccess.getPrimitiveTypeAccess().getTypeLiteralTypeEnumRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__TargetNameAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getTargetNameSTRINGTerminalRuleCall_5_0()); }
	RULE_STRING{ after(grammarAccess.getPrimitiveTypeAccess().getTargetNameSTRINGTerminalRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__CastNameAssignment_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getCastNameFQNParserRuleCall_6_1_0()); }
	ruleFQN{ after(grammarAccess.getPrimitiveTypeAccess().getCastNameFQNParserRuleCall_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__DefaultValueLiteralAssignment_8
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_8_0()); }
	RULE_STRING{ after(grammarAccess.getPrimitiveTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PrimitiveType__DocuAssignment_9
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPrimitiveTypeAccess().getDocuDocumentationParserRuleCall_9_0()); }
	ruleDocumentation{ after(grammarAccess.getPrimitiveTypeAccess().getDocuDocumentationParserRuleCall_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getEnumerationTypeAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getEnumerationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__PrimitiveTypeAssignment_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeCrossReference_3_1_0()); }
(
{ before(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeFQNParserRuleCall_3_1_0_1()); }
	ruleFQN{ after(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeFQNParserRuleCall_3_1_0_1()); }
)
{ after(grammarAccess.getEnumerationTypeAccess().getPrimitiveTypePrimitiveTypeCrossReference_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__LiteralsAssignment_5_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_0_0()); }
	ruleEnumLiteral{ after(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumerationType__LiteralsAssignment_5_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_1_1_0()); }
	ruleEnumLiteral{ after(grammarAccess.getEnumerationTypeAccess().getLiteralsEnumLiteralParserRuleCall_5_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__NameAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0_0()); }
	RULE_ID{ after(grammarAccess.getEnumLiteralAccess().getNameIDTerminalRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumLiteral__LiteralAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumLiteralAccess().getLiteralIntLiteralParserRuleCall_1_1_0()); }
	ruleIntLiteral{ after(grammarAccess.getEnumLiteralAccess().getLiteralIntLiteralParserRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getExternalTypeAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__TargetNameAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getTargetNameSTRINGTerminalRuleCall_3_0()); }
	RULE_STRING{ after(grammarAccess.getExternalTypeAccess().getTargetNameSTRINGTerminalRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__DefaultValueLiteralAssignment_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_4_1_0()); }
	RULE_STRING{ after(grammarAccess.getExternalTypeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalType__DocuAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalTypeAccess().getDocuDocumentationParserRuleCall_5_0()); }
	ruleDocumentation{ after(grammarAccess.getExternalTypeAccess().getDocuDocumentationParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getDataClassAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getDataClassAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__BaseAssignment_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getBaseDataClassCrossReference_3_1_0()); }
(
{ before(grammarAccess.getDataClassAccess().getBaseDataClassFQNParserRuleCall_3_1_0_1()); }
	ruleFQN{ after(grammarAccess.getDataClassAccess().getBaseDataClassFQNParserRuleCall_3_1_0_1()); }
)
{ after(grammarAccess.getDataClassAccess().getBaseDataClassCrossReference_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__AnnotationsAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getAnnotationsAnnotationParserRuleCall_5_0()); }
	ruleAnnotation{ after(grammarAccess.getDataClassAccess().getAnnotationsAnnotationParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__UserCode1Assignment_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUserCode1DetailCodeParserRuleCall_6_1_0()); }
	ruleDetailCode{ after(grammarAccess.getDataClassAccess().getUserCode1DetailCodeParserRuleCall_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__UserCode2Assignment_7_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUserCode2DetailCodeParserRuleCall_7_1_0()); }
	ruleDetailCode{ after(grammarAccess.getDataClassAccess().getUserCode2DetailCodeParserRuleCall_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__UserCode3Assignment_8_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getUserCode3DetailCodeParserRuleCall_8_1_0()); }
	ruleDetailCode{ after(grammarAccess.getDataClassAccess().getUserCode3DetailCodeParserRuleCall_8_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__OperationsAssignment_9_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getOperationsStandardOperationParserRuleCall_9_0_0()); }
	ruleStandardOperation{ after(grammarAccess.getDataClassAccess().getOperationsStandardOperationParserRuleCall_9_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__StructorsAssignment_9_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getStructorsClassStructorParserRuleCall_9_1_0()); }
	ruleClassStructor{ after(grammarAccess.getDataClassAccess().getStructorsClassStructorParserRuleCall_9_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DataClass__AttributesAssignment_9_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDataClassAccess().getAttributesAttributeParserRuleCall_9_2_0()); }
	ruleAttribute{ after(grammarAccess.getDataClassAccess().getAttributesAttributeParserRuleCall_9_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getAttributeAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__SizeAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getSizeINTTerminalRuleCall_2_1_0()); }
	RULE_INT{ after(grammarAccess.getAttributeAccess().getSizeINTTerminalRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__TypeAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getTypeRefableTypeParserRuleCall_4_0()); }
	ruleRefableType{ after(grammarAccess.getAttributeAccess().getTypeRefableTypeParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__DefaultValueLiteralAssignment_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_5_1_0()); }
	RULE_STRING{ after(grammarAccess.getAttributeAccess().getDefaultValueLiteralSTRINGTerminalRuleCall_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Attribute__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAttributeAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getAttributeAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__OverrideAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); }
(
{ before(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); }

	'override' 

{ after(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); }
)

{ after(grammarAccess.getStandardOperationAccess().getOverrideOverrideKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getStandardOperationAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__ArgumentsAssignment_4_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_0_0()); }
	ruleVarDecl{ after(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__ArgumentsAssignment_4_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_1_1_0()); }
	ruleVarDecl{ after(grammarAccess.getStandardOperationAccess().getArgumentsVarDeclParserRuleCall_4_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__ReturnTypeAssignment_6_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getReturnTypeRefableTypeParserRuleCall_6_1_1_0()); }
	ruleRefableType{ after(grammarAccess.getStandardOperationAccess().getReturnTypeRefableTypeParserRuleCall_6_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__DocuAssignment_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getDocuDocumentationParserRuleCall_7_0()); }
	ruleDocumentation{ after(grammarAccess.getStandardOperationAccess().getDocuDocumentationParserRuleCall_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StandardOperation__DetailCodeAssignment_8
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStandardOperationAccess().getDetailCodeDetailCodeParserRuleCall_8_0()); }
	ruleDetailCode{ after(grammarAccess.getStandardOperationAccess().getDetailCodeDetailCodeParserRuleCall_8_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getPortOperationAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__ArgumentsAssignment_3_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_0_0()); }
	ruleVarDecl{ after(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__ArgumentsAssignment_3_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_1_1_0()); }
	ruleVarDecl{ after(grammarAccess.getPortOperationAccess().getArgumentsVarDeclParserRuleCall_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__ReturnTypeAssignment_5_0_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getReturnTypeRefableTypeParserRuleCall_5_0_1_1_0()); }
	ruleRefableType{ after(grammarAccess.getPortOperationAccess().getReturnTypeRefableTypeParserRuleCall_5_0_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__SendsMsgAssignment_5_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getSendsMsgMessageCrossReference_5_1_1_0()); }
(
{ before(grammarAccess.getPortOperationAccess().getSendsMsgMessageIDTerminalRuleCall_5_1_1_0_1()); }
	RULE_ID{ after(grammarAccess.getPortOperationAccess().getSendsMsgMessageIDTerminalRuleCall_5_1_1_0_1()); }
)
{ after(grammarAccess.getPortOperationAccess().getSendsMsgMessageCrossReference_5_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getPortOperationAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortOperation__DetailCodeAssignment_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortOperationAccess().getDetailCodeDetailCodeParserRuleCall_7_0()); }
	ruleDetailCode{ after(grammarAccess.getPortOperationAccess().getDetailCodeDetailCodeParserRuleCall_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ClassStructor__NameAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getClassStructorAccess().getNameAlternatives_0_0()); }
(rule__ClassStructor__NameAlternatives_0_0)
{ after(grammarAccess.getClassStructorAccess().getNameAlternatives_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ClassStructor__DetailCodeAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getClassStructorAccess().getDetailCodeDetailCodeParserRuleCall_1_0()); }
	ruleDetailCode{ after(grammarAccess.getClassStructorAccess().getDetailCodeDetailCodeParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__CommTypeAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getCommTypeCommunicationTypeEnumRuleCall_0_0()); }
	ruleCommunicationType{ after(grammarAccess.getProtocolClassAccess().getCommTypeCommunicationTypeEnumRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getProtocolClassAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__DocuAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getDocuDocumentationParserRuleCall_3_0()); }
	ruleDocumentation{ after(grammarAccess.getProtocolClassAccess().getDocuDocumentationParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__BaseAssignment_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getBaseProtocolClassCrossReference_4_1_0()); }
(
{ before(grammarAccess.getProtocolClassAccess().getBaseProtocolClassFQNParserRuleCall_4_1_0_1()); }
	ruleFQN{ after(grammarAccess.getProtocolClassAccess().getBaseProtocolClassFQNParserRuleCall_4_1_0_1()); }
)
{ after(grammarAccess.getProtocolClassAccess().getBaseProtocolClassCrossReference_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__AnnotationsAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); }
	ruleAnnotation{ after(grammarAccess.getProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__UserCode1Assignment_7_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUserCode1DetailCodeParserRuleCall_7_1_0()); }
	ruleDetailCode{ after(grammarAccess.getProtocolClassAccess().getUserCode1DetailCodeParserRuleCall_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__UserCode2Assignment_8_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUserCode2DetailCodeParserRuleCall_8_1_0()); }
	ruleDetailCode{ after(grammarAccess.getProtocolClassAccess().getUserCode2DetailCodeParserRuleCall_8_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__UserCode3Assignment_9_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getUserCode3DetailCodeParserRuleCall_9_1_0()); }
	ruleDetailCode{ after(grammarAccess.getProtocolClassAccess().getUserCode3DetailCodeParserRuleCall_9_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__IncomingMessagesAssignment_10_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getIncomingMessagesMessageParserRuleCall_10_2_0()); }
	ruleMessage{ after(grammarAccess.getProtocolClassAccess().getIncomingMessagesMessageParserRuleCall_10_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__OutgoingMessagesAssignment_11_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getOutgoingMessagesMessageParserRuleCall_11_2_0()); }
	ruleMessage{ after(grammarAccess.getProtocolClassAccess().getOutgoingMessagesMessageParserRuleCall_11_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__RegularAssignment_12_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getRegularPortClassParserRuleCall_12_2_0()); }
	rulePortClass{ after(grammarAccess.getProtocolClassAccess().getRegularPortClassParserRuleCall_12_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__ConjugatedAssignment_13_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getConjugatedPortClassParserRuleCall_13_2_0()); }
	rulePortClass{ after(grammarAccess.getProtocolClassAccess().getConjugatedPortClassParserRuleCall_13_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolClass__SemanticsAssignment_14
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolClassAccess().getSemanticsProtocolSemanticsParserRuleCall_14_0()); }
	ruleProtocolSemantics{ after(grammarAccess.getProtocolClassAccess().getSemanticsProtocolSemanticsParserRuleCall_14_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getCompoundProtocolClassAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getCompoundProtocolClassAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__AnnotationsAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
	ruleAnnotation{ after(grammarAccess.getCompoundProtocolClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CompoundProtocolClass__SubProtocolsAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsSubProtocolParserRuleCall_5_0()); }
	ruleSubProtocol{ after(grammarAccess.getCompoundProtocolClassAccess().getSubProtocolsSubProtocolParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubProtocol__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubProtocolAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getSubProtocolAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubProtocol__ProtocolAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassCrossReference_3_0()); }
(
{ before(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_3_0_1()); }
	ruleFQN{ after(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_3_0_1()); }
)
{ after(grammarAccess.getSubProtocolAccess().getProtocolGeneralProtocolClassCrossReference_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Message__PrivAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); }
(
{ before(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); }

	'private' 

{ after(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); }
)

{ after(grammarAccess.getMessageAccess().getPrivPrivateKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Message__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getMessageAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Message__DataAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); }
	ruleVarDecl{ after(grammarAccess.getMessageAccess().getDataVarDeclParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Message__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getMessageAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__UserCodeAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getUserCodeDetailCodeParserRuleCall_2_1_0()); }
	ruleDetailCode{ after(grammarAccess.getPortClassAccess().getUserCodeDetailCodeParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__MsgHandlersAssignment_3_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getMsgHandlersMessageHandlerParserRuleCall_3_0_0()); }
	ruleMessageHandler{ after(grammarAccess.getPortClassAccess().getMsgHandlersMessageHandlerParserRuleCall_3_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__OperationsAssignment_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getOperationsPortOperationParserRuleCall_3_1_0()); }
	rulePortOperation{ after(grammarAccess.getPortClassAccess().getOperationsPortOperationParserRuleCall_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__PortClass__AttributesAssignment_3_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortClassAccess().getAttributesAttributeParserRuleCall_3_2_0()); }
	ruleAttribute{ after(grammarAccess.getPortClassAccess().getAttributesAttributeParserRuleCall_3_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InMessageHandler__MsgAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInMessageHandlerAccess().getMsgMessageCrossReference_2_0()); }
(
{ before(grammarAccess.getInMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getInMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getInMessageHandlerAccess().getMsgMessageCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InMessageHandler__DetailCodeAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); }
	ruleDetailCode{ after(grammarAccess.getInMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutMessageHandler__MsgAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getMsgMessageCrossReference_2_0()); }
(
{ before(grammarAccess.getOutMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getOutMessageHandlerAccess().getMsgMessageIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getOutMessageHandlerAccess().getMsgMessageCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutMessageHandler__DetailCodeAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); }
	ruleDetailCode{ after(grammarAccess.getOutMessageHandlerAccess().getDetailCodeDetailCodeParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__AbstractAssignment_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); }
(
{ before(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); }

	'abstract' 

{ after(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); }
)

{ after(grammarAccess.getActorClassAccess().getAbstractAbstractKeyword_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__CommTypeAssignment_0_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); }
	ruleComponentCommunicationType{ after(grammarAccess.getActorClassAccess().getCommTypeComponentCommunicationTypeEnumRuleCall_0_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getActorClassAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__DocuAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getDocuDocumentationParserRuleCall_3_0()); }
	ruleDocumentation{ after(grammarAccess.getActorClassAccess().getDocuDocumentationParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__BaseAssignment_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBaseActorClassCrossReference_4_1_0()); }
(
{ before(grammarAccess.getActorClassAccess().getBaseActorClassFQNParserRuleCall_4_1_0_1()); }
	ruleFQN{ after(grammarAccess.getActorClassAccess().getBaseActorClassFQNParserRuleCall_4_1_0_1()); }
)
{ after(grammarAccess.getActorClassAccess().getBaseActorClassCrossReference_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__AnnotationsAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); }
	ruleAnnotation{ after(grammarAccess.getActorClassAccess().getAnnotationsAnnotationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__ServiceProvisionPointsAssignment_7_2_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getServiceProvisionPointsSPPParserRuleCall_7_2_0_0()); }
	ruleSPP{ after(grammarAccess.getActorClassAccess().getServiceProvisionPointsSPPParserRuleCall_7_2_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__InterfacePortsAssignment_7_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getInterfacePortsPortParserRuleCall_7_2_1_0()); }
	rulePort{ after(grammarAccess.getActorClassAccess().getInterfacePortsPortParserRuleCall_7_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__StructureDocuAssignment_8_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getStructureDocuDocumentationParserRuleCall_8_1_0()); }
	ruleDocumentation{ after(grammarAccess.getActorClassAccess().getStructureDocuDocumentationParserRuleCall_8_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__UserCode1Assignment_8_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUserCode1DetailCodeParserRuleCall_8_3_1_0()); }
	ruleDetailCode{ after(grammarAccess.getActorClassAccess().getUserCode1DetailCodeParserRuleCall_8_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__UserCode2Assignment_8_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUserCode2DetailCodeParserRuleCall_8_4_1_0()); }
	ruleDetailCode{ after(grammarAccess.getActorClassAccess().getUserCode2DetailCodeParserRuleCall_8_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__UserCode3Assignment_8_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getUserCode3DetailCodeParserRuleCall_8_5_1_0()); }
	ruleDetailCode{ after(grammarAccess.getActorClassAccess().getUserCode3DetailCodeParserRuleCall_8_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__ConnectionsAssignment_8_6_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getConnectionsLayerConnectionParserRuleCall_8_6_0_0()); }
	ruleLayerConnection{ after(grammarAccess.getActorClassAccess().getConnectionsLayerConnectionParserRuleCall_8_6_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__BindingsAssignment_8_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBindingsBindingParserRuleCall_8_6_1_0()); }
	ruleBinding{ after(grammarAccess.getActorClassAccess().getBindingsBindingParserRuleCall_8_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__ServiceImplementationsAssignment_8_6_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getServiceImplementationsServiceImplementationParserRuleCall_8_6_2_0()); }
	ruleServiceImplementation{ after(grammarAccess.getActorClassAccess().getServiceImplementationsServiceImplementationParserRuleCall_8_6_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__AttributesAssignment_8_6_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getAttributesAttributeParserRuleCall_8_6_3_0()); }
	ruleAttribute{ after(grammarAccess.getActorClassAccess().getAttributesAttributeParserRuleCall_8_6_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__ActorRefsAssignment_8_6_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getActorRefsActorRefParserRuleCall_8_6_4_0()); }
	ruleActorRef{ after(grammarAccess.getActorClassAccess().getActorRefsActorRefParserRuleCall_8_6_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__ServiceAccessPointsAssignment_8_6_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getServiceAccessPointsSAPParserRuleCall_8_6_5_0()); }
	ruleSAP{ after(grammarAccess.getActorClassAccess().getServiceAccessPointsSAPParserRuleCall_8_6_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__InternalPortsAssignment_8_6_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getInternalPortsPortParserRuleCall_8_6_6_0()); }
	rulePort{ after(grammarAccess.getActorClassAccess().getInternalPortsPortParserRuleCall_8_6_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__ExternalPortsAssignment_8_6_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getExternalPortsExternalPortParserRuleCall_8_6_7_0()); }
	ruleExternalPort{ after(grammarAccess.getActorClassAccess().getExternalPortsExternalPortParserRuleCall_8_6_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__BehaviorDocuAssignment_9_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBehaviorDocuDocumentationParserRuleCall_9_1_0()); }
	ruleDocumentation{ after(grammarAccess.getActorClassAccess().getBehaviorDocuDocumentationParserRuleCall_9_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__BehaviorAnnotationsAssignment_9_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAnnotationParserRuleCall_9_3_0()); }
	ruleAnnotation{ after(grammarAccess.getActorClassAccess().getBehaviorAnnotationsAnnotationParserRuleCall_9_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__OperationsAssignment_9_4_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getOperationsStandardOperationParserRuleCall_9_4_0_0()); }
	ruleStandardOperation{ after(grammarAccess.getActorClassAccess().getOperationsStandardOperationParserRuleCall_9_4_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__StructorsAssignment_9_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getStructorsClassStructorParserRuleCall_9_4_1_0()); }
	ruleClassStructor{ after(grammarAccess.getActorClassAccess().getStructorsClassStructorParserRuleCall_9_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorClass__StateMachineAssignment_9_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorClassAccess().getStateMachineStateMachineParserRuleCall_9_5_0()); }
	ruleStateMachine{ after(grammarAccess.getActorClassAccess().getStateMachineStateMachineParserRuleCall_9_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Port__ConjugatedAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); }
(
{ before(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); }

	'conjugated' 

{ after(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); }
)

{ after(grammarAccess.getPortAccess().getConjugatedConjugatedKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Port__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getPortAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Port__MultiplicityAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); }
	ruleMULTIPLICITY{ after(grammarAccess.getPortAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Port__ProtocolAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassCrossReference_5_0()); }
(
{ before(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_5_0_1()); }
	ruleFQN{ after(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassFQNParserRuleCall_5_0_1()); }
)
{ after(grammarAccess.getPortAccess().getProtocolGeneralProtocolClassCrossReference_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Port__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getPortAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getPortAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExternalPort__InterfacePortAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExternalPortAccess().getInterfacePortPortCrossReference_2_0()); }
(
{ before(grammarAccess.getExternalPortAccess().getInterfacePortPortIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getExternalPortAccess().getInterfacePortPortIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getExternalPortAccess().getInterfacePortPortCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SAP__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSAPAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getSAPAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SAP__ProtocolAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSAPAccess().getProtocolProtocolClassCrossReference_3_0()); }
(
{ before(grammarAccess.getSAPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); }
	ruleFQN{ after(grammarAccess.getSAPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); }
)
{ after(grammarAccess.getSAPAccess().getProtocolProtocolClassCrossReference_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SPP__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getSPPAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SPP__ProtocolAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPAccess().getProtocolProtocolClassCrossReference_3_0()); }
(
{ before(grammarAccess.getSPPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); }
	ruleFQN{ after(grammarAccess.getSPPAccess().getProtocolProtocolClassFQNParserRuleCall_3_0_1()); }
)
{ after(grammarAccess.getSPPAccess().getProtocolProtocolClassCrossReference_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ServiceImplementation__SppAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getServiceImplementationAccess().getSppSPPCrossReference_2_0()); }
(
{ before(grammarAccess.getServiceImplementationAccess().getSppSPPIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getServiceImplementationAccess().getSppSPPIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getServiceImplementationAccess().getSppSPPCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getLogicalSystemAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getLogicalSystemAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__AnnotationsAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
	ruleAnnotation{ after(grammarAccess.getLogicalSystemAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__ConnectionsAssignment_5_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getConnectionsLayerConnectionParserRuleCall_5_0_0()); }
	ruleLayerConnection{ after(grammarAccess.getLogicalSystemAccess().getConnectionsLayerConnectionParserRuleCall_5_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__BindingsAssignment_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getBindingsBindingParserRuleCall_5_1_0()); }
	ruleBinding{ after(grammarAccess.getLogicalSystemAccess().getBindingsBindingParserRuleCall_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalSystem__SubSystemsAssignment_5_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalSystemAccess().getSubSystemsSubSystemRefParserRuleCall_5_2_0()); }
	ruleSubSystemRef{ after(grammarAccess.getLogicalSystemAccess().getSubSystemsSubSystemRefParserRuleCall_5_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getSubSystemRefAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__TypeAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassCrossReference_3_0()); }
(
{ before(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassFQNParserRuleCall_3_0_1()); }
	ruleFQN{ after(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassFQNParserRuleCall_3_0_1()); }
)
{ after(grammarAccess.getSubSystemRefAccess().getTypeSubSystemClassCrossReference_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemRef__DocuAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemRefAccess().getDocuDocumentationParserRuleCall_4_0()); }
	ruleDocumentation{ after(grammarAccess.getSubSystemRefAccess().getDocuDocumentationParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getSubSystemClassAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getSubSystemClassAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__AnnotationsAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
	ruleAnnotation{ after(grammarAccess.getSubSystemClassAccess().getAnnotationsAnnotationParserRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__UserCode1Assignment_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUserCode1DetailCodeParserRuleCall_5_1_0()); }
	ruleDetailCode{ after(grammarAccess.getSubSystemClassAccess().getUserCode1DetailCodeParserRuleCall_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__UserCode2Assignment_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUserCode2DetailCodeParserRuleCall_6_1_0()); }
	ruleDetailCode{ after(grammarAccess.getSubSystemClassAccess().getUserCode2DetailCodeParserRuleCall_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__UserCode3Assignment_7_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getUserCode3DetailCodeParserRuleCall_7_1_0()); }
	ruleDetailCode{ after(grammarAccess.getSubSystemClassAccess().getUserCode3DetailCodeParserRuleCall_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__ActorInstanceMappingsAssignment_8_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_8_0_0()); }
	ruleActorInstanceMapping{ after(grammarAccess.getSubSystemClassAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_8_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__ThreadsAssignment_8_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getThreadsLogicalThreadParserRuleCall_8_1_0()); }
	ruleLogicalThread{ after(grammarAccess.getSubSystemClassAccess().getThreadsLogicalThreadParserRuleCall_8_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__ConnectionsAssignment_8_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getConnectionsLayerConnectionParserRuleCall_8_2_0()); }
	ruleLayerConnection{ after(grammarAccess.getSubSystemClassAccess().getConnectionsLayerConnectionParserRuleCall_8_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__BindingsAssignment_8_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getBindingsBindingParserRuleCall_8_3_0()); }
	ruleBinding{ after(grammarAccess.getSubSystemClassAccess().getBindingsBindingParserRuleCall_8_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__ActorRefsAssignment_8_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getActorRefsActorRefParserRuleCall_8_4_0()); }
	ruleActorRef{ after(grammarAccess.getSubSystemClassAccess().getActorRefsActorRefParserRuleCall_8_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__ServiceProvisionPointsAssignment_8_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsSPPParserRuleCall_8_5_0()); }
	ruleSPP{ after(grammarAccess.getSubSystemClassAccess().getServiceProvisionPointsSPPParserRuleCall_8_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubSystemClass__RelayPortsAssignment_8_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubSystemClassAccess().getRelayPortsPortParserRuleCall_8_6_0()); }
	rulePort{ after(grammarAccess.getSubSystemClassAccess().getRelayPortsPortParserRuleCall_8_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LogicalThread__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLogicalThreadAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getLogicalThreadAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__PathAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getPathRefPathParserRuleCall_1_0()); }
	ruleRefPath{ after(grammarAccess.getActorInstanceMappingAccess().getPathRefPathParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__ThreadAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadCrossReference_3_0()); }
(
{ before(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadIDTerminalRuleCall_3_0_1()); }
	RULE_ID{ after(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadIDTerminalRuleCall_3_0_1()); }
)
{ after(grammarAccess.getActorInstanceMappingAccess().getThreadLogicalThreadCrossReference_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorInstanceMapping__ActorInstanceMappingsAssignment_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_4_1_0()); }
	ruleActorInstanceMapping{ after(grammarAccess.getActorInstanceMappingAccess().getActorInstanceMappingsActorInstanceMappingParserRuleCall_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefPath__RefsAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_0_0()); }
	ruleRefSegment{ after(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefPath__RefsAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_1_1_0()); }
	ruleRefSegment{ after(grammarAccess.getRefPathAccess().getRefsRefSegmentParserRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefSegment__RefAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSegmentAccess().getRefIDTerminalRuleCall_0_0()); }
	RULE_ID{ after(grammarAccess.getRefSegmentAccess().getRefIDTerminalRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefSegment__IdxAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSegmentAccess().getIdxINTTerminalRuleCall_1_1_0()); }
	RULE_INT{ after(grammarAccess.getRefSegmentAccess().getIdxINTTerminalRuleCall_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Binding__Endpoint1Assignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingAccess().getEndpoint1BindingEndPointParserRuleCall_1_0()); }
	ruleBindingEndPoint{ after(grammarAccess.getBindingAccess().getEndpoint1BindingEndPointParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Binding__Endpoint2Assignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingAccess().getEndpoint2BindingEndPointParserRuleCall_3_0()); }
	ruleBindingEndPoint{ after(grammarAccess.getBindingAccess().getEndpoint2BindingEndPointParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__ActorRefAssignment_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefCrossReference_0_0_0()); }
(
{ before(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefIDTerminalRuleCall_0_0_0_1()); }
	RULE_ID{ after(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefIDTerminalRuleCall_0_0_0_1()); }
)
{ after(grammarAccess.getBindingEndPointAccess().getActorRefActorContainerRefCrossReference_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__PortAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getPortPortCrossReference_1_0()); }
(
{ before(grammarAccess.getBindingEndPointAccess().getPortPortIDTerminalRuleCall_1_0_1()); }
	RULE_ID{ after(grammarAccess.getBindingEndPointAccess().getPortPortIDTerminalRuleCall_1_0_1()); }
)
{ after(grammarAccess.getBindingEndPointAccess().getPortPortCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__BindingEndPoint__SubAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBindingEndPointAccess().getSubSubProtocolCrossReference_2_1_0()); }
(
{ before(grammarAccess.getBindingEndPointAccess().getSubSubProtocolIDTerminalRuleCall_2_1_0_1()); }
	RULE_ID{ after(grammarAccess.getBindingEndPointAccess().getSubSubProtocolIDTerminalRuleCall_2_1_0_1()); }
)
{ after(grammarAccess.getBindingEndPointAccess().getSubSubProtocolCrossReference_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LayerConnection__FromAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLayerConnectionAccess().getFromSAPointParserRuleCall_1_0()); }
	ruleSAPoint{ after(grammarAccess.getLayerConnectionAccess().getFromSAPointParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__LayerConnection__ToAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getLayerConnectionAccess().getToSPPointParserRuleCall_3_0()); }
	ruleSPPoint{ after(grammarAccess.getLayerConnectionAccess().getToSPPointParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefSAPoint__RefAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefSAPointAccess().getRefActorContainerRefCrossReference_1_0()); }
(
{ before(grammarAccess.getRefSAPointAccess().getRefActorContainerRefIDTerminalRuleCall_1_0_1()); }
	RULE_ID{ after(grammarAccess.getRefSAPointAccess().getRefActorContainerRefIDTerminalRuleCall_1_0_1()); }
)
{ after(grammarAccess.getRefSAPointAccess().getRefActorContainerRefCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RelaySAPoint__RelayAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRelaySAPointAccess().getRelaySPPCrossReference_1_0()); }
(
{ before(grammarAccess.getRelaySAPointAccess().getRelaySPPIDTerminalRuleCall_1_0_1()); }
	RULE_ID{ after(grammarAccess.getRelaySAPointAccess().getRelaySPPIDTerminalRuleCall_1_0_1()); }
)
{ after(grammarAccess.getRelaySAPointAccess().getRelaySPPCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SPPoint__RefAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPointAccess().getRefActorContainerRefCrossReference_0_0()); }
(
{ before(grammarAccess.getSPPointAccess().getRefActorContainerRefIDTerminalRuleCall_0_0_1()); }
	RULE_ID{ after(grammarAccess.getSPPointAccess().getRefActorContainerRefIDTerminalRuleCall_0_0_1()); }
)
{ after(grammarAccess.getSPPointAccess().getRefActorContainerRefCrossReference_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SPPoint__ServiceAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSPPointAccess().getServiceSPPCrossReference_2_0()); }
(
{ before(grammarAccess.getSPPointAccess().getServiceSPPIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getSPPointAccess().getServiceSPPIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getSPPointAccess().getServiceSPPCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__RefTypeAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getRefTypeReferenceTypeEnumRuleCall_0_0()); }
	ruleReferenceType{ after(grammarAccess.getActorRefAccess().getRefTypeReferenceTypeEnumRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getActorRefAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__MultiplicityAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); }
	ruleMULTIPLICITY{ after(grammarAccess.getActorRefAccess().getMultiplicityMULTIPLICITYParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__TypeAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getTypeActorClassCrossReference_5_0()); }
(
{ before(grammarAccess.getActorRefAccess().getTypeActorClassFQNParserRuleCall_5_0_1()); }
	ruleFQN{ after(grammarAccess.getActorRefAccess().getTypeActorClassFQNParserRuleCall_5_0_1()); }
)
{ after(grammarAccess.getActorRefAccess().getTypeActorClassCrossReference_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ActorRef__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getActorRefAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getActorRefAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


rule__StateGraph__StatesAssignment_2_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); }
	ruleState{ after(grammarAccess.getStateGraphAccess().getStatesStateParserRuleCall_2_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__TrPointsAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); }
	ruleTrPoint{ after(grammarAccess.getStateGraphAccess().getTrPointsTrPointParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__ChPointsAssignment_2_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); }
	ruleChoicePoint{ after(grammarAccess.getStateGraphAccess().getChPointsChoicePointParserRuleCall_2_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__TransitionsAssignment_2_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); }
	ruleTransition{ after(grammarAccess.getStateGraphAccess().getTransitionsTransitionParserRuleCall_2_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateGraph__RefinedTransitionsAssignment_2_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); }
	ruleRefinedTransition{ after(grammarAccess.getStateGraphAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_2_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__StatesAssignment_3_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); }
	ruleState{ after(grammarAccess.getStateMachineAccess().getStatesStateParserRuleCall_3_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__TrPointsAssignment_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); }
	ruleTrPoint{ after(grammarAccess.getStateMachineAccess().getTrPointsTrPointParserRuleCall_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__ChPointsAssignment_3_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); }
	ruleChoicePoint{ after(grammarAccess.getStateMachineAccess().getChPointsChoicePointParserRuleCall_3_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__TransitionsAssignment_3_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); }
	ruleTransition{ after(grammarAccess.getStateMachineAccess().getTransitionsTransitionParserRuleCall_3_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateMachine__RefinedTransitionsAssignment_3_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); }
	ruleRefinedTransition{ after(grammarAccess.getStateMachineAccess().getRefinedTransitionsRefinedTransitionParserRuleCall_3_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getSimpleStateAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getSimpleStateAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__EntryCodeAssignment_3_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); }
	ruleDetailCode{ after(grammarAccess.getSimpleStateAccess().getEntryCodeDetailCodeParserRuleCall_3_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__ExitCodeAssignment_3_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); }
	ruleDetailCode{ after(grammarAccess.getSimpleStateAccess().getExitCodeDetailCodeParserRuleCall_3_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__DoCodeAssignment_3_3_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); }
	ruleDetailCode{ after(grammarAccess.getSimpleStateAccess().getDoCodeDetailCodeParserRuleCall_3_3_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleState__SubgraphAssignment_3_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); }
	ruleStateGraph{ after(grammarAccess.getSimpleStateAccess().getSubgraphStateGraphParserRuleCall_3_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__TargetAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); }
(
{ before(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); }
	ruleFQN{ after(grammarAccess.getRefinedStateAccess().getTargetStateFQNParserRuleCall_1_0_1()); }
)
{ after(grammarAccess.getRefinedStateAccess().getTargetStateCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getRefinedStateAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__EntryCodeAssignment_4_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); }
	ruleDetailCode{ after(grammarAccess.getRefinedStateAccess().getEntryCodeDetailCodeParserRuleCall_4_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__ExitCodeAssignment_5_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); }
	ruleDetailCode{ after(grammarAccess.getRefinedStateAccess().getExitCodeDetailCodeParserRuleCall_5_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__DoCodeAssignment_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); }
	ruleDetailCode{ after(grammarAccess.getRefinedStateAccess().getDoCodeDetailCodeParserRuleCall_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedState__SubgraphAssignment_7_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); }
	ruleStateGraph{ after(grammarAccess.getRefinedStateAccess().getSubgraphStateGraphParserRuleCall_7_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DetailCode__UsedAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); }
(
{ before(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); }

	'{' 

{ after(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); }
)

{ after(grammarAccess.getDetailCodeAccess().getUsedLeftCurlyBracketKeyword_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__DetailCode__LinesAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_2_0()); }
	RULE_STRING{ after(grammarAccess.getDetailCodeAccess().getLinesSTRINGTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionPoint__HandlerAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); }
(
{ before(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); }

	'handler' 

{ after(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); }
)

{ after(grammarAccess.getTransitionPointAccess().getHandlerHandlerKeyword_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TransitionPoint__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getTransitionPointAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EntryPoint__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getEntryPointAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ExitPoint__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getExitPointAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicePoint__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getChoicePointAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicePoint__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getChoicePointAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getInitialTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__ToAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getInitialTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getInitialTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InitialTransition__ActionAssignment_7_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); }
	ruleDetailCode{ after(grammarAccess.getInitialTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getContinuationTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__FromAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getContinuationTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__ToAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getContinuationTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getContinuationTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ContinuationTransition__ActionAssignment_7_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); }
	ruleDetailCode{ after(grammarAccess.getContinuationTransitionAccess().getActionDetailCodeParserRuleCall_7_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getTriggeredTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__FromAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getTriggeredTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__ToAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getTriggeredTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getTriggeredTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__TriggersAssignment_10
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); }
	ruleTrigger{ after(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_10_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__TriggersAssignment_11_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); }
	ruleTrigger{ after(grammarAccess.getTriggeredTransitionAccess().getTriggersTriggerParserRuleCall_11_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TriggeredTransition__ActionAssignment_13_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); }
	ruleDetailCode{ after(grammarAccess.getTriggeredTransitionAccess().getActionDetailCodeParserRuleCall_13_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getGuardedTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__FromAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getGuardedTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__ToAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getGuardedTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getGuardedTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__GuardAssignment_9
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); }
	ruleDetailCode{ after(grammarAccess.getGuardedTransitionAccess().getGuardDetailCodeParserRuleCall_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__GuardedTransition__ActionAssignment_10_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); }
	ruleDetailCode{ after(grammarAccess.getGuardedTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getCPBranchTransitionAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__FromAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getCPBranchTransitionAccess().getFromTransitionTerminalParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__ToAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
	ruleTransitionTerminal{ after(grammarAccess.getCPBranchTransitionAccess().getToTransitionTerminalParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__DocuAssignment_6
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
	ruleDocumentation{ after(grammarAccess.getCPBranchTransitionAccess().getDocuDocumentationParserRuleCall_6_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__ConditionAssignment_9
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); }
	ruleDetailCode{ after(grammarAccess.getCPBranchTransitionAccess().getConditionDetailCodeParserRuleCall_9_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__CPBranchTransition__ActionAssignment_10_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); }
	ruleDetailCode{ after(grammarAccess.getCPBranchTransitionAccess().getActionDetailCodeParserRuleCall_10_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__TargetAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); }
(
{ before(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); }
	ruleFQN{ after(grammarAccess.getRefinedTransitionAccess().getTargetTransitionFQNParserRuleCall_1_0_1()); }
)
{ after(grammarAccess.getRefinedTransitionAccess().getTargetTransitionCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getRefinedTransitionAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RefinedTransition__ActionAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); }
	ruleDetailCode{ after(grammarAccess.getRefinedTransitionAccess().getActionDetailCodeParserRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StateTerminal__StateAssignment
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); }
(
{ before(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); }
	RULE_ID{ after(grammarAccess.getStateTerminalAccess().getStateStateIDTerminalRuleCall_0_1()); }
)
{ after(grammarAccess.getStateTerminalAccess().getStateStateCrossReference_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__TrPointTerminal__TrPointAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); }
(
{ before(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); }
	RULE_ID{ after(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_1_0_1()); }
)
{ after(grammarAccess.getTrPointTerminalAccess().getTrPointTrPointCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubStateTrPointTerminal__TrPointAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); }
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); }
	RULE_ID{ after(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointIDTerminalRuleCall_0_0_1()); }
)
{ after(grammarAccess.getSubStateTrPointTerminalAccess().getTrPointTrPointCrossReference_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SubStateTrPointTerminal__StateAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); }
(
{ before(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getSubStateTrPointTerminalAccess().getStateStateCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ChoicepointTerminal__CpAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); }
(
{ before(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); }
	RULE_ID{ after(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointIDTerminalRuleCall_1_0_1()); }
)
{ after(grammarAccess.getChoicepointTerminalAccess().getCpChoicePointCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__MsgFromIfPairsAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); }
	ruleMessageFromIf{ after(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__MsgFromIfPairsAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); }
	ruleMessageFromIf{ after(grammarAccess.getTriggerAccess().getMsgFromIfPairsMessageFromIfParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Trigger__GuardAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); }
	ruleGuard{ after(grammarAccess.getTriggerAccess().getGuardGuardParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MessageFromIf__MessageAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); }
(
{ before(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); }
	RULE_ID{ after(grammarAccess.getMessageFromIfAccess().getMessageEObjectIDTerminalRuleCall_0_0_1()); }
)
{ after(grammarAccess.getMessageFromIfAccess().getMessageEObjectCrossReference_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__MessageFromIf__FromAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); }
(
{ before(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getMessageFromIfAccess().getFromAbstractInterfaceItemCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Guard__GuardAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); }
	ruleDetailCode{ after(grammarAccess.getGuardAccess().getGuardDetailCodeParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__ProtocolSemantics__RulesAssignment_3
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getProtocolSemanticsAccess().getRulesSemanticsRuleParserRuleCall_3_0()); }
	ruleSemanticsRule{ after(grammarAccess.getProtocolSemanticsAccess().getRulesSemanticsRuleParserRuleCall_3_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__MsgAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); }
(
{ before(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getInSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__FollowUpsAssignment_3_1_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); }
	ruleSemanticsRule{ after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__FollowUpsAssignment_3_1_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); }
	ruleSemanticsRule{ after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__InSemanticsRule__FollowUpsAssignment_3_1_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); }
	ruleSemanticsRule{ after(grammarAccess.getInSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__MsgAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); }
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); }
	RULE_ID{ after(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectIDTerminalRuleCall_2_0_1()); }
)
{ after(grammarAccess.getOutSemanticsRuleAccess().getMsgEObjectCrossReference_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__FollowUpsAssignment_3_1_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); }
	ruleSemanticsRule{ after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); }
	ruleSemanticsRule{ after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__OutSemanticsRule__FollowUpsAssignment_3_1_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); }
	ruleSemanticsRule{ after(grammarAccess.getOutSemanticsRuleAccess().getFollowUpsSemanticsRuleParserRuleCall_3_1_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__TypeAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeCrossReference_1_0()); }
(
{ before(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeFQNParserRuleCall_1_0_1()); }
	ruleFQN{ after(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeFQNParserRuleCall_1_0_1()); }
)
{ after(grammarAccess.getAnnotationAccess().getTypeAnnotationTypeCrossReference_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__AttributesAssignment_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_1_0()); }
	ruleKeyValue{ after(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Annotation__AttributesAssignment_2_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_2_1_0()); }
	ruleKeyValue{ after(grammarAccess.getAnnotationAccess().getAttributesKeyValueParserRuleCall_2_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__KeyValue__KeyAssignment_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); }
	RULE_ID{ after(grammarAccess.getKeyValueAccess().getKeyIDTerminalRuleCall_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__KeyValue__ValueAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); }
	ruleLiteral{ after(grammarAccess.getKeyValueAccess().getValueLiteralParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__NameAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getNameIDTerminalRuleCall_1_0()); }
	RULE_ID{ after(grammarAccess.getAnnotationTypeAccess().getNameIDTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__DocuAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); }
	ruleDocumentation{ after(grammarAccess.getAnnotationTypeAccess().getDocuDocumentationParserRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__TargetsAssignment_6_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_0_0()); }
	ruleAnnotationTargetType{ after(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__TargetsAssignment_6_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_1_0()); }
	ruleAnnotationTargetType{ after(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__TargetsAssignment_6_1_2_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_2_1_0()); }
	ruleAnnotationTargetType{ after(grammarAccess.getAnnotationTypeAccess().getTargetsAnnotationTargetTypeParserRuleCall_6_1_2_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__AnnotationType__AttributesAssignment_7
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getAnnotationTypeAccess().getAttributesAnnotationAttributeParserRuleCall_7_0()); }
	ruleAnnotationAttribute{ after(grammarAccess.getAnnotationTypeAccess().getAttributesAnnotationAttributeParserRuleCall_7_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__OptionalAssignment_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }

	'optional' 

{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }
)

{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__SimpleAnnotationAttribute__TypeAssignment_4
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); }
	ruleLiteralType{ after(grammarAccess.getSimpleAnnotationAttributeAccess().getTypeLiteralTypeEnumRuleCall_4_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__OptionalAssignment_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }

	'optional' 

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }
)

{ after(grammarAccess.getEnumAnnotationAttributeAccess().getOptionalOptionalKeyword_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__NameAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); }
	RULE_ID{ after(grammarAccess.getEnumAnnotationAttributeAccess().getNameIDTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__ValuesAssignment_5
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); }
	RULE_STRING{ after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_5_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__EnumAnnotationAttribute__ValuesAssignment_6_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); }
	RULE_STRING{ after(grammarAccess.getEnumAnnotationAttributeAccess().getValuesSTRINGTerminalRuleCall_6_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Import__ImportedNamespaceAssignment_1_0_0
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getImportedNamespaceImportedFQNParserRuleCall_1_0_0_0()); }
	ruleImportedFQN{ after(grammarAccess.getImportAccess().getImportedNamespaceImportedFQNParserRuleCall_1_0_0_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Import__ImportURIAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getImportAccess().getImportURISTRINGTerminalRuleCall_2_0()); }
	RULE_STRING{ after(grammarAccess.getImportAccess().getImportURISTRINGTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__Documentation__LinesAssignment_2
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); }
	RULE_STRING{ after(grammarAccess.getDocumentationAccess().getLinesSTRINGTerminalRuleCall_2_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}



rule__BooleanLiteral__IsTrueAssignment_1_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
(
{ before(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }

	'true' 

{ after(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
)

{ after(grammarAccess.getBooleanLiteralAccess().getIsTrueTrueKeyword_1_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__RealLiteral__ValueAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); }
	ruleReal{ after(grammarAccess.getRealLiteralAccess().getValueRealParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__IntLiteral__ValueAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); }
	ruleInteger{ after(grammarAccess.getIntLiteralAccess().getValueIntegerParserRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}

rule__StringLiteral__ValueAssignment_1
    @init {
		int stackSize = keepStackSize();
    }
:
(
{ before(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); }
	RULE_STRING{ after(grammarAccess.getStringLiteralAccess().getValueSTRINGTerminalRuleCall_1_0()); }
)

;
finally {
	restoreStackSize(stackSize);
}


RULE_EXP : ('e'|'E') ('+'|'-')? ('0'..'9')+;

RULE_HEX : ('0x'|'0X') ('0'..'9'|'a'..'f'|'A'..'F')+;

RULE_ID : '^'? ('a'..'z'|'A'..'Z'|'_') ('a'..'z'|'A'..'Z'|'_'|'0'..'9')*;

RULE_INT : ('0'..'9')+;

RULE_STRING : ('"' ('\\' .|~(('\\'|'"')))* '"'|'\'' ('\\' .|~(('\\'|'\'')))* '\'');

RULE_ML_COMMENT : '/*' ( options {greedy=false;} : . )*'*/';

RULE_SL_COMMENT : '//' ~(('\n'|'\r'))* ('\r'? '\n')?;

RULE_WS : (' '|'\t'|'\r'|'\n')+;

RULE_ANY_OTHER : .;